toppers/raw_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: raw_stub.hpp,v 1.1.1.1 2004/04/14 09:30:30 takagi-n Exp $
 */

#ifndef TOPPERS_RAW_STUB_HPP_
#define TOPPERS_RAW_STUB_HPP_

#include <toppers/kernel.hpp>
#include <cstdlib>

namespace toppers
{

    template <bool Exist = true>
    class raw_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);
    };

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_tsk(ID tskid, t_ctsk* pk_ctsk)
    {
        return cre_tsk(tskid, pk_ctsk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_tsk(ID tskid, const t_ctsk* pk_ctsk)
    {
        if (sizeof cre_tsk(tskid, pk_ctsk) != sizeof(ER))
        {
            t_ctsk packet = *pk_ctsk;
            return cre_tsk(tskid, &packet);
        }
        return cre_tsk(tskid, const_cast<t_ctsk*>(pk_ctsk));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_tsk(ID tskid)
    {
        return del_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_act_tsk(ID tskid)
    {
        return act_tsk(tskid);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_can_act(ID tskid)
    {
        return can_act(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sta_tsk(ID tskid, VP_INT stacd)
    {
        return sta_tsk(tskid, stacd);
    }
    template <bool Exist>
    inline void raw_stub<Exist>::stub_ext_tsk()
    {
        ext_tsk();
    }
    template <bool Exist>
    inline void raw_stub<Exist>::stub_exd_tsk()
    {
        exd_tsk();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ter_tsk(ID tskid)
    {
        return ter_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_chg_pri(ID tskid, PRI tskpri)
    {
        return chg_pri(tskid, tskpri);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_pri(ID tskid, PRI* p_tskpri)
    {
        return get_pri(tskid, p_tskpri);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_tsk(ID tskid, t_rtsk* pk_rtsk)
    {
        return ref_tsk(tskid, pk_rtsk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_tst(ID tskid, t_rtst* pk_rtst)
    {
        return ref_tst(tskid, pk_rtst);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_slp_tsk()
    {
        return slp_tsk();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tslp_tsk(TMO tmout)
    {
        return tslp_tsk(tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_wup_tsk(ID tskid)
    {
        return wup_tsk(tskid);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_can_wup(ID tskid)
    {
        return can_wup(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rel_wai(ID tskid)
    {
        return rel_wai(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sus_tsk(ID tskid)
    {
        return sus_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rsm_tsk(ID tskid)
    {
        return rsm_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_frsm_tsk(ID tskid)
    {
        return frsm_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_dly_tsk(RELTIM dlytim)
    {
        return dly_tsk(dlytim);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_tex(ID tskid, t_dtex* pk_dtex)
    {
        return def_tex(tskid, pk_dtex);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_tex(ID tskid, const t_dtex* pk_dtex)
    {
        if (sizeof def_tex(tskid, pk_dtex) != sizeof(ER))
        {
            t_dtex packet = *pk_dtex;
            return def_tex(tskid, &packet);
        }
        return def_tex(tskid, const_cast<t_dtex*>(pk_dtex));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ras_tex(ID tskid, TEXPTN rasptn)
    {
        return ras_tex(tskid, rasptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_dis_tex()
    {
        return dis_tex();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ena_tex()
    {
        return ena_tex();
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_sns_tex()
    {
        return sns_tex();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_tex(ID tskid, t_rtex* pk_rtex)
    {
        return ref_tex(tskid, pk_rtex);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_sem(ID semid, t_csem* pk_csem)
    {
        return cre_sem(semid, pk_csem);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_sem(ID semid, const t_csem* pk_csem)
    {
        if (sizeof cre_sem(semid, pk_csem) != sizeof(ER))
        {
            t_csem packet = *pk_csem;
            return cre_sem(semid, &packet);
        }
        return cre_sem(semid, const_cast<t_csem*>(pk_csem));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_sem(ID semid)
    {
        return del_sem(semid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sig_sem(ID semid)
    {
        return sig_sem(semid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_wai_sem(ID semid)
    {
        return wai_sem(semid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_pol_sem(ID semid)
    {
        return pol_sem(semid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_twai_sem(ID semid, TMO tmout)
    {
        return twai_sem(semid, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_sem(ID semid, t_rsem* pk_rsem)
    {
        return ref_sem(semid, pk_rsem);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_flg(ID flgid, t_cflg* pk_cflg)
    {
        return cre_flg(flgid, pk_cflg);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_flg(ID flgid, const t_cflg* pk_cflg)
    {
        if (sizeof cre_flg(flgid, pk_cflg) != sizeof(ER))
        {
            t_cflg packet = *pk_cflg;
            return cre_flg(flgid, &packet);
        }
        return cre_flg(flgid, const_cast<t_cflg*>(pk_cflg));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_flg(ID flgid)
    {
        return del_flg(flgid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_set_flg(ID flgid, FLGPTN setptn)
    {
        return set_flg(flgid, setptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_clr_flg(ID flgid, FLGPTN clrptn)
    {
        return clr_flg(flgid, clrptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_wai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn)
    {
        return wai_flg(flgid, waiptn, wfmode, p_flgptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_pol_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn)
    {
        return pol_flg(flgid, waiptn, wfmode, p_flgptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn, TMO tmout)
    {
        return twai_flg(flgid, waiptn, wfmode, p_flgptn, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_flg(ID flgid, t_rflg* pk_rflg)
    {
        return ref_flg(flgid, pk_rflg);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_dtq(ID dtqid, t_cdtq* pk_cdtq)
    {
        return cre_dtq(dtqid, pk_cdtq);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_dtq(ID dtqid, const t_cdtq* pk_cdtq)
    {
        if (sizeof cre_dtq(dtqid, pk_cdtq) != sizeof(ER))
        {
            t_cdtq packet = *pk_cdtq;
            return cre_dtq(dtqid, &packet);
        }
        return cre_dtq(dtqid, const_cast<t_cdtq*>(pk_cdtq));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_dtq(ID dtqid)
    {
        return del_dtq(dtqid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_snd_dtq(ID dtqid, VP_INT data)
    {
        return snd_dtq(dtqid, data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_psnd_dtq(ID dtqid, VP_INT data)
    {
        return psnd_dtq(dtqid, data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tsnd_dtq(ID dtqid, VP_INT data, TMO tmout)
    {
        return tsnd_dtq(dtqid, data, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_fsnd_dtq(ID dtqid, VP_INT data)
    {
        return fsnd_dtq(dtqid, data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rcv_dtq(ID dtqid, VP_INT* p_data)
    {
        return rcv_dtq(dtqid, p_data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_prcv_dtq(ID dtqid, VP_INT* p_data)
    {
        return prcv_dtq(dtqid, p_data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_trcv_dtq(ID dtqid, VP_INT* p_data, TMO tmout)
    {
        return trcv_dtq(dtqid, p_data, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_dtq(ID dtqid, t_rdtq* pk_rdtq)
    {
        return ref_dtq(dtqid, pk_rdtq);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mbx(ID mbxid, t_cmbx* pk_cmbx)
    {
        return cre_mbx(mbxid, pk_cmbx);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mbx(ID mbxid, const t_cmbx* pk_cmbx)
    {
        if (sizeof cre_mbx(mbxid, pk_cmbx) != sizeof(ER))
        {
            t_cmbx packet = *pk_cmbx;
            return cre_mbx(mbxid, &packet);
        }
        return cre_mbx(mbxid, const_cast<t_cmbx*>(pk_cmbx));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_mbx(ID mbxid)
    {
        return del_mbx(mbxid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_snd_mbx(ID mbxid, T_MSG* pk_msg)
    {
        return snd_mbx(mbxid, pk_msg);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rcv_mbx(ID mbxid, T_MSG** ppk_msg)
    {
        return rcv_mbx(mbxid, ppk_msg);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_prcv_mbx(ID mbxid, T_MSG** ppk_msg)
    {
        return prcv_mbx(mbxid, ppk_msg);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_trcv_mbx(ID mbxid, T_MSG** ppk_msg, TMO tmout)
    {
        return trcv_mbx(mbxid, ppk_msg, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_mbx(ID mbxid, t_rmbx* pk_rmbx)
    {
        return ref_mbx(mbxid, pk_rmbx);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mpf(ID mpfid, t_cmpf* pk_cmpf)
    {
        return cre_mpf(mpfid, pk_cmpf);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mpf(ID mpfid, const t_cmpf* pk_cmpf)
    {
        if (sizeof cre_mpf(mpfid, pk_cmpf) != sizeof(ER))
        {
            t_cmpf packet = *pk_cmpf;
            return cre_mpf(mpfid, &packet);
        }
        return cre_mpf(mpfid, const_cast<t_cmpf*>(pk_cmpf));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_mpf(ID mpfid)
    {
        return del_mpf(mpfid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rel_mpf(ID mpfid, VP blk)
    {
        return rel_mpf(mpfid, blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_mpf(ID mpfid, VP* p_blk)
    {
        return get_mpf(mpfid, p_blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_pget_mpf(ID mpfid, VP* p_blk)
    {
        return pget_mpf(mpfid, p_blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tget_mpf(ID mpfid, VP* p_blk, TMO tmout)
    {
        return tget_mpf(mpfid, p_blk, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_mpf(ID mpfid, t_rmpf* pk_rmpf)
    {
        return ref_mpf(mpfid, pk_rmpf);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_set_tim(SYSTIM* p_systim)
    {
        return set_tim(p_systim);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_set_tim(const SYSTIM* p_systim)
    {
        if (sizeof set_tim(p_systim) != sizeof(ER))
        {
            SYSTIM packet = *p_systim;
            return set_tim(&packet);
        }
        return set_tim(const_cast<SYSTIM*>(p_systim));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_tim(SYSTIM* p_systim)
    {
        return get_tim(p_systim);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_cyc(ID cycid, t_ccyc* pk_ccyc)
    {
        return cre_cyc(cycid, pk_ccyc);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_cyc(ID cycid, const t_ccyc* pk_ccyc)
    {
        if (sizeof cre_cyc(cycid, pk_ccyc) != sizeof(ER))
        {
            t_ccyc packet = *pk_ccyc;
            return cre_cyc(cycid, &packet);
        }
        return cre_cyc(cycid, const_cast<t_ccyc*>(pk_ccyc));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_cyc(ID cycid)
    {
        return del_cyc(cycid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sta_cyc(ID cycid)
    {
        return sta_cyc(cycid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_stp_cyc(ID cycid)
    {
        return stp_cyc(cycid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_cyc(ID cycid, t_rcyc* pk_rcyc)
    {
        return ref_cyc(cycid, pk_rcyc);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rot_rdq(PRI tskpri)
    {
        return rot_rdq(tskpri);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_tid(ID* p_tskid)
    {
        return get_tid(p_tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_loc_cpu()
    {
        return loc_cpu();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_unl_cpu()
    {
        return unl_cpu();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_dis_dsp()
    {
        return dis_dsp();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ena_dsp()
    {
        return ena_dsp();
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_sns_ctx()
    {
        return sns_ctx();
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_sns_loc()
    {
        return sns_loc();
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_sns_dsp()
    {
        return sns_dsp();
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_sns_dpn()
    {
        return sns_dpn();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_sys(t_rsys* pk_rsys)
    {
        return ref_sys(pk_rsys);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_inh(INHNO inhno, t_dinh* pk_dinh)
    {
        return def_inh(inhno, pk_dinh);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_inh(INHNO inhno, const t_dinh* pk_dinh)
    {
        if (sizeof def_inh(inhno, pk_dinh) != sizeof(ER))
        {
            t_dinh packet = *pk_dinh;
            return def_inh(inhno, &packet);
        }
        return def_inh(inhno, const_cast<t_dinh*>(pk_dinh));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_isr(ID isrid, t_cisr* pk_cisr)
    {
        return cre_isr(isrid, pk_cisr);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_isr(ID isrid, const t_cisr* pk_cisr)
    {
        if (sizeof cre_isr(isrid, pk_cisr) != sizeof(ER))
        {
            t_cisr packet = *pk_cisr;
            return cre_isr(isrid, &packet);
        }
        return cre_isr(isrid, const_cast<t_cisr*>(pk_cisr));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_isr(ID isrid)
    {
        return del_isr(isrid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_isr(ID isrid, t_risr* pk_risr)
    {
        return ref_isr(isrid, pk_risr);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_dis_int(INTNO intno)
    {
        return dis_int(intno);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ena_int(INTNO intno)
    {
        return ena_int(intno);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_chg_ims(IMS ims)
    {
        return chg_ims(ims);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_ims(IMS* p_ims)
    {
        return get_ims(p_ims);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_svc(FN fncd, t_dsvc* pk_dsvc)
    {
        return def_svc(fncd, pk_dsvc);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_svc(FN fncd, const t_dsvc* pk_dsvc)
    {
        if (sizeof def_svc(fncd, pk_dsvc) != sizeof(ER))
        {
            t_dsvc packet = *pk_dsvc;
            return def_svc(fncd, &packet);
        }
        return def_svc(fncd, const_cast<t_dsvc*>(pk_dsvc));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_exc(EXCNO excno, t_dexc* pk_dexc)
    {
        return def_exc(excno, pk_dexc);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_exc(EXCNO excno, const t_dexc* pk_dexc)
    {
        if (sizeof def_exc(excno, pk_dexc) != sizeof(ER))
        {
            t_dexc packet = *pk_dexc;
            return def_exc(excno, &packet);
        }
        return def_exc(excno, const_cast<t_dexc*>(pk_dexc));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_cfg(t_rcfg* pk_rcfg)
    {
        return ref_cfg(pk_rcfg);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_ver(t_rver* pk_rver)
    {
        return ref_ver(pk_rver);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iact_tsk(ID tskid)
    {
        return iact_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iwup_tsk(ID tskid)
    {
        return iwup_tsk(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_irel_wai(ID tskid)
    {
        return irel_wai(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iras_tex(ID tskid, TEXPTN rasptn)
    {
        return iras_tex(tskid, rasptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_isig_sem(ID semid)
    {
        return isig_sem(semid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iset_flg(ID flgid, FLGPTN setptn)
    {
        return iset_flg(flgid, setptn);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ipsnd_dtq(ID dtqid, VP_INT data)
    {
        return ipsnd_dtq(dtqid, data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ifsnd_dtq(ID dtqid, VP_INT data)
    {
        return ifsnd_dtq(dtqid, data);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_irot_rdq(PRI tskpri)
    {
        return irot_rdq(tskpri);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iget_tid(ID* p_tskid)
    {
        return iget_tid(p_tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iloc_cpu()
    {
        return iloc_cpu();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_iunl_cpu()
    {
        return iunl_cpu();
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_isig_tim()
    {
        return isig_tim();
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mtx(ID mtxid, t_cmtx* pk_cmtx)
    {
        return cre_mtx(mtxid, pk_cmtx);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mtx(ID mtxid, const t_cmtx* pk_cmtx)
    {
        if (sizeof cre_mtx(mtxid, pk_cmtx) != sizeof(ER))
        {
            t_cmtx packet = *pk_cmtx;
            return cre_mtx(mtxid, &packet);
        }
        return cre_mtx(mtxid, const_cast<t_cmtx*>(pk_cmtx));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_mtx(ID mtxid)
    {
        return del_mtx(mtxid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_unl_mtx(ID mtxid)
    {
        return unl_mtx(mtxid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_loc_mtx(ID mtxid)
    {
        return loc_mtx(mtxid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ploc_mtx(ID mtxid)
    {
        return ploc_mtx(mtxid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tloc_mtx(ID mtxid, TMO tmout)
    {
        return tloc_mtx(mtxid, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_mtx(ID mtxid, t_rmtx* pk_rmtx)
    {
        return ref_mtx(mtxid, pk_rmtx);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mbf(ID mbfid, t_cmbf* pk_cmbf)
    {
        return cre_mbf(mbfid, pk_cmbf);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mbf(ID mbfid, const t_cmbf* pk_cmbf)
    {
        if (sizeof cre_mbf(mbfid, pk_cmbf) != sizeof(ER))
        {
            t_cmbf packet = *pk_cmbf;
            return cre_mbf(mbfid, &packet);
        }
        return cre_mbf(mbfid, const_cast<t_cmbf*>(pk_cmbf));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_mbf(ID mbfid)
    {
        return del_mbf(mbfid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_snd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return snd_mbf(mbfid, const_cast<void*>(msg), msgsz);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_psnd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return psnd_mbf(mbfid, const_cast<void*>(msg), msgsz);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tsnd_mbf(ID mbfid, const void* msg, UINT msgsz, TMO tmout)
    {
        return tsnd_mbf(mbfid, const_cast<void*>(msg), msgsz, tmout);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_rcv_mbf(ID mbfid, void* msg)
    {
        return rcv_mbf(mbfid, msg);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_prcv_mbf(ID mbfid, void* msg)
    {
        return prcv_mbf(mbfid, msg);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_trcv_mbf(ID mbfid, void* msg, TMO tmout)
    {
        return trcv_mbf(mbfid, msg, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_mbf(ID mbfid, t_rmbf* pk_rmbf)
    {
        return ref_mbf(mbfid, pk_rmbf);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_por(ID porid, t_cpor* pk_cpor)
    {
        return cre_por(porid, pk_cpor);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_por(ID porid, const t_cpor* pk_cpor)
    {
        if (sizeof cre_por(porid, pk_cpor) != sizeof(ER))
        {
            t_cpor packet = *pk_cpor;
            return cre_por(porid, &packet);
        }
        return cre_por(porid, const_cast<t_cpor*>(pk_cpor));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_por(ID porid)
    {
        return del_por(porid);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz)
    {
        return cal_por(porid, calptn, msg, cmsgsz);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_tcal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz, TMO tmout)
    {
        return tcal_por(porid, calptn, msg, cmsgsz, tmout);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_acp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return acp_por(porid, acpptn, p_rdvno, msg);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_pacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return pacp_por(porid, acpptn, p_rdvno, msg);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_tacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg, TMO tmout)
    {
        return tacp_por(porid, acpptn, p_rdvno, msg, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_fwd_por(ID porid, RDVPTN acpptn, RDVNO rdvno, const void* msg, UINT cmsgsz)
    {
        return fwd_por(porid, acpptn, rdvno, const_cast<void*>(msg), cmsgsz);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rpl_rdv(RDVNO rdvno, const void* msg, UINT rmsgsz)
    {
        return rpl_rdv(rdvno, const_cast<void*>(msg), rmsgsz);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_por(ID porid, t_rpor* pk_rpor)
    {
        return ref_por(porid, pk_rpor);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_rdv(RDVNO rdvid, t_rrdv* pk_rrdv)
    {
        return ref_rdv(rdvid, pk_rrdv);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mpl(ID mplid, t_cmpl* pk_cmpl)
    {
        return cre_mpl(mplid, pk_cmpl);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_mpl(ID mplid, const t_cmpl* pk_cmpl)
    {
        if (sizeof cre_mpl(mplid, pk_cmpl) != sizeof(ER))
        {
            t_cmpl packet = *pk_cmpl;
            return cre_mpl(mplid, &packet);
        }
        return cre_mpl(mplid, const_cast<t_cmpl*>(pk_cmpl));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_mpl(ID mplid)
    {
        return del_mpl(mplid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_rel_mpl(ID mplid, VP blk)
    {
        return rel_mpl(mplid, blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_get_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return get_mpl(mplid, blksz, p_blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_pget_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return pget_mpl(mplid, blksz, p_blk);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_tget_mpl(ID mplid, UINT blksz, VP* p_blk, TMO tmout)
    {
        return tget_mpl(mplid, blksz, p_blk, tmout);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_mpl(ID mplid, t_rmpl* pk_rmpl)
    {
        return ref_mpl(mplid, pk_rmpl);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_alm(ID almid, t_calm* pk_calm)
    {
        return cre_alm(almid, pk_calm);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_cre_alm(ID almid, const t_calm* pk_calm)
    {
        if (sizeof cre_alm(almid, pk_calm) != sizeof(ER))
        {
            t_calm packet = *pk_calm;
            return cre_alm(almid, &packet);
        }
        return cre_alm(almid, const_cast<t_calm*>(pk_calm));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_del_alm(ID almid)
    {
        return del_alm(almid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sta_alm(ID almid, RELTIM almtim)
    {
        return sta_alm(almid, almtim);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_stp_alm(ID almid)
    {
        return stp_alm(almid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_alm(ID almid, t_ralm* pk_ralm)
    {
        return ref_alm(almid, pk_ralm);
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_ovr(t_dovr* pk_dovr)
    {
        return def_ovr(pk_dovr);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_def_ovr(const t_dovr* pk_dovr)
    {
        if (sizeof def_ovr(pk_dovr) != sizeof(ER))
        {
            t_dovr packet = *pk_dovr;
            return def_ovr(&packet);
        }
        return def_ovr(const_cast<t_dovr*>(pk_dovr));
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_sta_ovr(ID tskid, OVRTIM ovrtim)
    {
        return sta_ovr(tskid, ovrtim);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_stp_ovr(ID tskid)
    {
        return stp_ovr(tskid);
    }
    template <bool Exist>
    inline ER raw_stub<Exist>::stub_ref_ovr(ID tskid, t_rovr* pk_rovr)
    {
        return ref_ovr(tskid, pk_rovr);
    }

    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_tsk(t_ctsk* pk_ctsk)
    {
        return acre_tsk(pk_ctsk);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_tsk(const t_ctsk* pk_ctsk)
    {
        if (sizeof acre_tsk(pk_ctsk) != sizeof(ER_ID))
        {
            t_ctsk packet = *pk_ctsk;
            return acre_tsk(&packet);
        }
        return acre_tsk(const_cast<t_ctsk*>(pk_ctsk));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_sem(t_csem* pk_csem)
    {
        return acre_sem(pk_csem);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_sem(const t_csem* pk_csem)
    {
        if (sizeof acre_sem(pk_csem) != sizeof(ER_ID))
        {
            t_csem packet = *pk_csem;
            return acre_sem(&packet);
        }
        return acre_sem(const_cast<t_csem*>(pk_csem));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_flg(t_cflg* pk_cflg)
    {
        return acre_flg(pk_cflg);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_flg(const t_cflg* pk_cflg)
    {
        if (sizeof acre_flg(pk_cflg) != sizeof(ER_ID))
        {
            t_cflg packet = *pk_cflg;
            return acre_flg(&packet);
        }
        return acre_flg(const_cast<t_cflg*>(pk_cflg));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_dtq(t_cdtq* pk_cdtq)
    {
        return acre_dtq(pk_cdtq);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_dtq(const t_cdtq* pk_cdtq)
    {
        if (sizeof acre_dtq(pk_cdtq) != sizeof(ER_ID))
        {
            t_cdtq packet = *pk_cdtq;
            return acre_dtq(&packet);
        }
        return acre_dtq(const_cast<t_cdtq*>(pk_cdtq));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mbx(t_cmbx* pk_cmbx)
    {
        return acre_mbx(pk_cmbx);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mbx(const t_cmbx* pk_cmbx)
    {
        if (sizeof acre_mbx(pk_cmbx) != sizeof(ER_ID))
        {
            t_cmbx packet = *pk_cmbx;
            return acre_mbx(&packet);
        }
        return acre_mbx(const_cast<t_cmbx*>(pk_cmbx));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mtx(t_cmtx* pk_cmtx)
    {
        return acre_mtx(pk_cmtx);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mtx(const t_cmtx* pk_cmtx)
    {
        if (sizeof acre_mtx(pk_cmtx) != sizeof(ER_ID))
        {
            t_cmtx packet = *pk_cmtx;
            return acre_mtx(&packet);
        }
        return acre_mtx(const_cast<t_cmtx*>(pk_cmtx));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mbf(t_cmbf* pk_cmbf)
    {
        return acre_mbf(pk_cmbf);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mbf(const t_cmbf* pk_cmbf)
    {
        if (sizeof acre_mbf(pk_cmbf) != sizeof(ER_ID))
        {
            t_cmbf packet = *pk_cmbf;
            return acre_mbf(&packet);
        }
        return acre_mbf(const_cast<t_cmbf*>(pk_cmbf));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_por(t_cpor* pk_cpor)
    {
        return acre_por(pk_cpor);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_por(const t_cpor* pk_cpor)
    {
        if (sizeof acre_por(pk_cpor) != sizeof(ER_ID))
        {
            t_cpor packet = *pk_cpor;
            return acre_por(&packet);
        }
        return acre_por(const_cast<t_cpor*>(pk_cpor));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mpf(t_cmpf* pk_cmpf)
    {
        return acre_mpf(pk_cmpf);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mpf(const t_cmpf* pk_cmpf)
    {
        if (sizeof acre_mpf(pk_cmpf) != sizeof(ER_ID))
        {
            t_cmpf packet = *pk_cmpf;
            return acre_mpf(&packet);
        }
        return acre_mpf(const_cast<t_cmpf*>(pk_cmpf));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mpl(t_cmpl* pk_cmpl)
    {
        return acre_mpl(pk_cmpl);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_mpl(const t_cmpl* pk_cmpl)
    {
        if (sizeof acre_mpl(pk_cmpl) != sizeof(ER_ID))
        {
            t_cmpl packet = *pk_cmpl;
            return acre_mpl(&packet);
        }
        return acre_mpl(const_cast<t_cmpl*>(pk_cmpl));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_cyc(t_ccyc* pk_ccyc)
    {
        return acre_cyc(pk_ccyc);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_cyc(const t_ccyc* pk_ccyc)
    {
        if (sizeof acre_cyc(pk_ccyc) != sizeof(ER_ID))
        {
            t_ccyc packet = *pk_ccyc;
            return acre_cyc(&packet);
        }
        return acre_cyc(const_cast<t_ccyc*>(pk_ccyc));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_alm(t_calm* pk_calm)
    {
        return acre_alm(pk_calm);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_alm(const t_calm* pk_calm)
    {
        if (sizeof acre_alm(pk_calm) != sizeof(ER_ID))
        {
            t_calm packet = *pk_calm;
            return acre_alm(&packet);
        }
        return acre_alm(const_cast<t_calm*>(pk_calm));
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_isr(t_cisr* pk_cisr)
    {
        return acre_isr(pk_cisr);
    }
    template <bool Exist>
    inline ER_ID raw_stub<Exist>::stub_acre_isr(const t_cisr* pk_cisr)
    {
        if (acre_isr(pk_cisr) != sizeof(ER_ID))
        {
            t_cisr packet = *pk_cisr;
            acre_isr(&packet);
        }
        return acre_isr(const_cast<t_cisr*>(pk_cisr));
    }

    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vxsns_ctx(VP_INT exinf)
    {
        return vxsns_ctx(exinf);
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vxsns_loc(VP_INT exinf)
    {
        return vxsns_loc(exinf);
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vxsns_dsp(VP_INT exinf)
    {
        return vxsns_dsp(exinf);
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vxsns_dpn(VP_INT exinf)
    {
        return vxsns_dpn(exinf);
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vxsns_tex(VP_INT exinf)
    {
        return vxsns_tex(exinf);
    }
    template <bool Exist>
    inline bool raw_stub<Exist>::stub_vsns_ini()
    {
        return vsns_ini();
    }

    template <bool Exist>
    inline ER raw_stub<Exist>::stub_vxget_tim(SYSUTIM* p_sysutim)
    {
        return vxget_tim(p_sysutim);
    }

    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd)
    {
        return cal_svc(fncd, 0, 0, 0, 0, 0);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd, VP_INT par1)
    {
        return cal_svc(fncd, par1, 0, 0, 0, 0);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2)
    {
        return cal_svc(fncd, par1, par2, 0, 0, 0);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3)
    {
        return cal_svc(fncd, par1, par2, par3, 0, 0);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4)
    {
        return cal_svc(fncd, par1, par2, par3, par4, 0);
    }
    template <bool Exist>
    inline ER_UINT raw_stub<Exist>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4, VP_INT par5)
    {
        return cal_svc(fncd, par1, par2, par3, par4, par5);
    }

    template <>
    inline ER raw_stub<false>::stub_cre_tsk(ID tskid, t_ctsk* pk_ctsk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_tsk(ID tskid, const t_ctsk* pk_ctsk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_tsk(ID tskid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_sta_tsk(ID tskid, VP_INT stacd)
    {
        return E_NOSPT;
    }
    template <>
    inline void raw_stub<false>::stub_exd_tsk()
    {
        std::exit(EXIT_FAILURE);
    }
    template <>
    inline ER raw_stub<false>::stub_ref_tsk(ID tskid, t_rtsk* pk_rtsk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_tst(ID tskid, t_rtst* pk_rtst)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_def_tex(ID tskid, t_dtex* pk_dtex)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_tex(ID tskid, const t_dtex* pk_dtex)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_tex(ID tskid, t_rtex* pk_rtex)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_sem(ID semid, t_csem* pk_csem)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_sem(ID semid, const t_csem* pk_csem)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_sem(ID semid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_sem(ID semid, t_rsem* pk_rsem)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_flg(ID flgid, t_cflg* pk_cflg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_flg(ID flgid, const t_cflg* pk_cflg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_flg(ID flgid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_flg(ID flgid, t_rflg* pk_rflg)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_dtq(ID dtqid, t_cdtq* pk_cdtq)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_dtq(ID dtqid, const t_cdtq* pk_cdtq)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_dtq(ID dtqid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_dtq(ID dtqid, t_rdtq* pk_rdtq)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_mbx(ID mbxid, t_cmbx* pk_cmbx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_mbx(ID mbxid, const t_cmbx* pk_cmbx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_mbx(ID mbxid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_mbx(ID mbxid, t_rmbx* pk_rmbx)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_mpf(ID mpfid, t_cmpf* pk_cmpf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_mpf(ID mpfid, const t_cmpf* pk_cmpf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_mpf(ID mpfid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_mpf(ID mpfid, t_rmpf* pk_rmpf)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_cyc(ID cycid, t_ccyc* pk_ccyc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_cyc(ID cycid, const t_ccyc* pk_ccyc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_cyc(ID cycid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_cyc(ID cycid, t_rcyc* pk_rcyc)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_ref_sys(t_rsys* pk_rsys)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_def_inh(INHNO inhno, t_dinh* pk_dinh)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_inh(INHNO inhno, const t_dinh* pk_dinh)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_isr(ID isrid, t_cisr* pk_cisr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_isr(ID isrid, const t_cisr* pk_cisr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_isr(ID isrid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_isr(ID isrid, t_risr* pk_risr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_dis_int(INTNO intno)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ena_int(INTNO intno)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_chg_ims(IMS ims)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_get_ims(IMS* p_ims)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_def_svc(FN fncd, t_dsvc* pk_dsvc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_svc(FN fncd, const t_dsvc* pk_dsvc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_exc(EXCNO excno, t_dexc* pk_dexc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_exc(EXCNO excno, const t_dexc* pk_dexc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_cfg(t_rcfg* pk_rcfg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_ver(t_rver* pk_rver)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_mtx(ID mtxid, t_cmtx* pk_cmtx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_mtx(ID mtxid, const t_cmtx* pk_cmtx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_mtx(ID mtxid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_unl_mtx(ID mtxid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_loc_mtx(ID mtxid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ploc_mtx(ID mtxid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_tloc_mtx(ID mtxid, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_mtx(ID mtxid, t_rmtx* pk_rmtx)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_mbf(ID mbfid, t_cmbf* pk_cmbf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_mbf(ID mbfid, const t_cmbf* pk_cmbf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_mbf(ID mbfid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_snd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_psnd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_tsnd_mbf(ID mbfid, const void* msg, UINT msgsz, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_rcv_mbf(ID mbfid, void* msg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_prcv_mbf(ID mbfid, void* msg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_trcv_mbf(ID mbfid, void* msg, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_mbf(ID mbfid, t_rmbf* pk_rmbf)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_por(ID porid, t_cpor* pk_cpor)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_por(ID porid, const t_cpor* pk_cpor)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_por(ID porid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_tcal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_acp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_pacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_tacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_fwd_por(ID porid, RDVPTN acpptn, RDVNO rdvno, const void* msg, UINT cmsgsz)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_rpl_rdv(RDVNO rdvno, const void* msg, UINT rmsgsz)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_por(ID porid, t_rpor* pk_rpor)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_rdv(RDVNO rdvid, t_rrdv* pk_rrdv)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_mpl(ID mplid, t_cmpl* pk_cmpl)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_mpl(ID mplid, const t_cmpl* pk_cmpl)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_mpl(ID mplid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_rel_mpl(ID mplid, VP blk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_get_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_pget_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_tget_mpl(ID mplid, UINT blksz, VP* p_blk, TMO tmout)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_mpl(ID mplid, t_rmpl* pk_rmpl)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_cre_alm(ID almid, t_calm* pk_calm)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_cre_alm(ID almid, const t_calm* pk_calm)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_del_alm(ID almid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_sta_alm(ID almid, RELTIM almtim)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_stp_alm(ID almid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_alm(ID almid, t_ralm* pk_ralm)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_def_ovr(t_dovr* pk_dovr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_def_ovr(const t_dovr* pk_dovr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_sta_ovr(ID tskid, OVRTIM ovrtim)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_stp_ovr(ID tskid)
    {
        return E_NOSPT;
    }
    template <>
    inline ER raw_stub<false>::stub_ref_ovr(ID tskid, t_rovr* pk_rovr)
    {
        return E_NOSPT;
    }

    template <>
    inline ER_ID raw_stub<false>::stub_acre_tsk(t_ctsk* pk_ctsk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_tsk(const t_ctsk* pk_ctsk)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_sem(t_csem* pk_csem)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_sem(const t_csem* pk_csem)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_flg(t_cflg* pk_cflg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_flg(const t_cflg* pk_cflg)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_dtq(t_cdtq* pk_cdtq)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_dtq(const t_cdtq* pk_cdtq)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mbx(t_cmbx* pk_cmbx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mbx(const t_cmbx* pk_cmbx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mtx(t_cmtx* pk_cmtx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mtx(const t_cmtx* pk_cmtx)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mbf(t_cmbf* pk_cmbf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mbf(const t_cmbf* pk_cmbf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_por(t_cpor* pk_cpor)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_por(const t_cpor* pk_cpor)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mpf(t_cmpf* pk_cmpf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mpf(const t_cmpf* pk_cmpf)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mpl(t_cmpl* pk_cmpl)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_mpl(const t_cmpl* pk_cmpl)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_cyc(t_ccyc* pk_ccyc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_cyc(const t_ccyc* pk_ccyc)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_alm(t_calm* pk_calm)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_alm(const t_calm* pk_calm)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_isr(t_cisr* pk_cisr)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_ID raw_stub<false>::stub_acre_isr(const t_cisr* pk_cisr)
    {
        return E_NOSPT;
    }

    template <>
    inline ER raw_stub<false>::stub_vxget_tim(SYSUTIM* p_sysutim)
    {
        return E_NOSPT;
    }

    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd, VP_INT par1)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4)
    {
        return E_NOSPT;
    }
    template <>
    inline ER_UINT raw_stub<false>::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4, VP_INT par5)
    {
        return E_NOSPT;
    }

}

#endif  // ! TOPPERS_RAW_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"の略称です。
• 本ページ中の商品名は，各社の商標または登録商標です。