kernel/include/object/tskobj.h

   1 /**
   2  *  Hyper Operating System V4 Advance
   3  *
   4  * @file  knl_que.h
   5  * @brief %jp{タスクブジェクトのヘッダファイル}%en{task object heder file}
   6  *
   7  * @version $Id: tskobj.h,v 1.4 2006-09-03 15:10:01 ryuz Exp $
   8  *
   9  * Copyright (C) 1998-2006 by Project HOS
  10  * http://sourceforge.jp/projects/hos/
  11  */
  12
  13
  14
  15 #ifndef _KERNEL__object__tskobj_h__
  16 #define _KERNEL__object__tskobj_h__
  17
  18
  19
  20 /* ------------------------------------------ */
  21 /*  Primitive type definition                 */
  22 /* ------------------------------------------ */
  23
  24 /* %jp{タスクハンドルの型}%en{Task-handle} */
  25 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合 */
  26 typedef int                                                             _KERNEL_TCB_T_TSKHDL;                   /**< %jp{タスクハンドルをTCBに格納するときの型} */
  27 #define _KERNEL_TCB_TBITDEF_TSKHDL              : _KERNEL_TBIT_TSKHDL                   /**< %jp{タスクハンドルのビットフィールド宣言時の幅} */
  28 #else
  29 typedef _KERNEL_T_TSKHDL                                _KERNEL_TCB_T_TSKHDL;                   /**< %jp{タスクハンドルをTCBに格納するときの型} */
  30 #define _KERNEL_TCB_TBITDEF_TSKHDL                                                                              /**< %jp{タスクハンドルのビットフィールド宣言時の幅} */
  31 #endif
  32
  33
  34 /* %jp{タスク状態の型}%en{Task-state} */
  35 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合 */
  36
  37 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
  38 typedef signed int                                              _KERNEL_TSK_T_TSKSTAT;                  /**< %jp{タスク状態を演算操作するときの型} */
  39 typedef signed int                                              _KERNEL_TCB_T_TSKSTAT;                  /**< %jp{タスク状態をTCBに格納するときの型} */
  40 #define _KERNEL_TCB_TBITDEF_TSKSTAT             : (_KERNEL_TSK_TBIT_TSKSTAT+1)  /**< %jp{タスク状態のビットフィールド宣言時の幅} */
  41 #else
  42 typedef unsigned int                                    _KERNEL_TSK_T_TSKSTAT;                  /**< %jp{タスク状態を演算操作するときの型} */
  43 typedef unsigned int                                    _KERNEL_TCB_T_TSKSTAT;                  /**< %jp{タスク状態をTCBに格納するときの型} */
  44 #define _KERNEL_TCB_TBITDEF_TSKSTAT             : _KERNEL_TSK_TBIT_TSKSTAT              /**< %jp{タスク状態のビットフィールド宣言時の幅} */
  45 #endif
  46
  47 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合 */
  48
  49 #if _KERNEL_OPT_SIGNED_INT
  50 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_TSKSTAT;                  /**< %jp{タスク状態を演算操作するときの型} */
  51 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_TSKSTAT;                  /**< %jp{タスク状態をTCBに格納するときの型} */
  52 #else
  53 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_TSKSTAT;                  /**< %jp{タスク状態を演算操作するときの型} */
  54 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_TSKSTAT;                  /**< %jp{タスク状態をTCBに格納するときの型} */
  55 #endif
  56 #define _KERNEL_TCB_TBITDEF_TSKSTAT                                                                             /**< %jp{タスク状態のビットフィールド宣言時の幅} */
  57
  58 #endif
  59
  60
  61 /* %jp{タスク優先度の型}%en{Task priopity} */
  62 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
  63
  64 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
  65 typedef signed int                                              _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  66 typedef signed int                                              _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  67 #define _KERNEL_TCB_TBITDEF_TPRI                : (_KERNEL_TSK_TBIT_TPRI+1)             /**< %jp{タスク優先度のビットフィールド宣言時の幅} */
  68 #else
  69 typedef unsigned int                                    _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  70 typedef unsigned int                                    _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  71 #define _KERNEL_TCB_TBITDEF_TPRI                : _KERNEL_TSK_TBIT_TPRI                 /**< %jp{タスク優先度のビットフィールド宣言時の幅} */
  72 #endif
  73
  74 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
  75
  76 #if (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
  77 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  78 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  79 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
  80 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  81 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  82 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
  83 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  84 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  85 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
  86 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  87 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  88 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
  89 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  90 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  91 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
  92 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  93 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  94 #elif (_KERNEL_TSK_TMAX_TPRI <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
  95 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  96 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
  97 #else
  98 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_TPRI;                             /**< %jp{タスク優先度を演算操作するときの型} */
  99 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_TPRI;                             /**< %jp{タスク優先度をTCBに格納するときの型} */
 100 #endif
 101 #define _KERNEL_TCB_TBITDEF_TPRI                                                                                /**< %jp{タスク優先度のビットフィールド宣言時の幅} */
 102
 103 #endif
 104
 105
 106 /* %jp{タスク待ち要因}%en{Task wait} */
 107 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 108
 109 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 110 typedef signed int                                              _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 111 typedef signed int                                              _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 112 #define _KERNEL_TCB_TBITDEF_TSKWAIT             : (_KERNEL_TSK_TBIT_TSKWAIT+1)  /**< %jp{タスク待ち要因のビットフィールド宣言時の幅} */
 113 #else
 114 typedef unsigned int                                    _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 115 typedef unsigned int                                    _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 116 #define _KERNEL_TCB_TBITDEF_TSKWAIT             : _KERNEL_TSK_TBIT_TSKWAIT              /**< %jp{タスク待ち要因のビットフィールド宣言時の幅} */
 117 #endif
 118
 119 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 120
 121 #if (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 122 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 123 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 124 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 125 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 126 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 127 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 128 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 129 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 130 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 131 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 132 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 133 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 134 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 135 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 136 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 137 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 138 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 139 #elif (_KERNEL_TSK_TMAX_TSKWAIT <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 140 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 141 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 142 #else
 143 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_TSKWAIT;                  /**< %jp{タスク待ち要因を演算操作するときの型} */
 144 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_TSKWAIT;                  /**< %jp{タスク待ち要因をTCBに格納するときの型} */
 145 #endif
 146 #define _KERNEL_TCB_TBITDEF_TSKWAIT                                                                             /**< %jp{タスク待ち要因のビットフィールド宣言時の幅} */
 147
 148 #endif
 149
 150
 151 /* %jp{待ち対象のオブジェクトのID番号}%jp{Waitbject-ID} */
 152 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 153
 154 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 155 typedef signed int                                              _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 156 typedef signed int                                              _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 157 #define _KERNEL_TCB_TBITDEF_WOBJID              : (_KERNEL_TSK_TBIT_WOBJID+1)   /**< %jp{待ち対象のオブジェクトのID番号のビットフィールド宣言時の幅} */
 158 #else
 159 typedef unsigned int                                    _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 160 typedef unsigned int                                    _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 161 #define _KERNEL_TCB_TBITDEF_WOBJID              : _KERNEL_TSK_TBIT_WOBJID               /**< %jp{待ち対象のオブジェクトのID番号のビットフィールド宣言時の幅} */
 162 #endif
 163
 164 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 165
 166 #if (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 167 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 168 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 169 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 170 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 171 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 172 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 173 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 174 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 175 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 176 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 177 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 178 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 179 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 180 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 181 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 182 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 183 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 184 #elif (_KERNEL_TSK_TMAX_WOBJID <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 185 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 186 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 187 #else
 188 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号を演算操作するときの型} */
 189 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_WOBJID;                   /**< %jp{待ち対象のオブジェクトのID番号をTCBに格納するときの型} */
 190 #endif
 191 #define _KERNEL_TCB_TBITDEF_WOBJID                                                                              /**< %jp{待ち対象のオブジェクトのID番号のビットフィールド宣言時の幅} */
 192
 193 #endif
 194
 195
 196 /* %jp{起動要求キューイング数}%en{Activate queuing count} */
 197 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 198
 199 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 200 typedef signed int                                              _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 201 typedef signed int                                              _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 202 #define _KERNEL_TCB_TBITDEF_ACTCNT              : (_KERNEL_TSK_TBIT_ACTCNT+1)   /**< %jp{起動要求キューイング数のビットフィールド宣言時の幅} */
 203 #else
 204 typedef unsigned int                                    _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 205 typedef unsigned int                                    _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 206 #define _KERNEL_TCB_TBITDEF_ACTCNT              : _KERNEL_TSK_TBIT_ACTCNT               /**< %jp{起動要求キューイング数のビットフィールド宣言時の幅} */
 207 #endif
 208
 209 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 210
 211 #if (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 212 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 213 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 214 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 215 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 216 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 217 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 218 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 219 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 220 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 221 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 222 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 223 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 224 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 225 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 226 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 227 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 228 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 229 #elif (_KERNEL_TSK_TMAX_ACTCNT <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 230 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 231 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 232 #else
 233 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_ACTCNT;                   /**< %jp{起動要求キューイング数を演算操作するときの型} */
 234 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_ACTCNT;                   /**< %jp{起動要求キューイング数をTCBに格納するときの型} */
 235 #endif
 236 #define _KERNEL_TCB_TBITDEF_ACTCNT                                                                              /**< %jp{起動要求キューイング数のビットフィールド宣言時の幅} */
 237
 238 #endif
 239
 240
 241 /*  %jp{起床要求キューイング数}%en{Wakeup queuing count} */
 242 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 243
 244 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 245 typedef signed int                                              _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 246 typedef signed int                                              _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 247 #define _KERNEL_TCB_TBITDEF_WUPCNT              : (_KERNEL_TSK_TBIT_WUPCNT+1)   /**< %jp{起床要求キューイング数のビットフィールド宣言時の幅} */
 248 #else
 249 typedef unsigned int                                    _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 250 typedef unsigned int                                    _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 251 #define _KERNEL_TCB_TBITDEF_WUPCNT              : _KERNEL_TSK_TBIT_WUPCNT               /**< %jp{起床要求キューイング数のビットフィールド宣言時の幅} */
 252 #endif
 253
 254 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 255
 256 #if (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 257 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 258 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 259 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 260 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 261 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 262 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 263 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 264 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 265 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 266 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 267 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 268 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 269 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 270 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 271 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 272 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 273 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 274 #elif (_KERNEL_TSK_TMAX_WUPCNT <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 275 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 276 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 277 #else
 278 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_WUPCNT;                   /**< %jp{起床要求キューイング数を演算操作するときの型} */
 279 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_WUPCNT;                   /**< %jp{起床要求キューイング数をTCBに格納するときの型} */
 280 #endif
 281 #define _KERNEL_TCB_TBITDEF_WUPCNT                                                                              /**< %jp{起床要求キューイング数のビットフィールド宣言時の幅} */
 282
 283 #endif
 284
 285
 286 /*  %jp{強制待ち要求ネスト数}%en{Suspend nest count} */
 287 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 288
 289 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 290 typedef signed int                                              _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 291 typedef signed int                                              _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 292 #define _KERNEL_TCB_TBITDEF_SUSCNT              : (_KERNEL_TSK_TBIT_SUSCNT+1)   /**< %jp{強制待ち要求ネスト数のビットフィールド宣言時の幅} */
 293 #else
 294 typedef unsigned int                                    _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 295 typedef unsigned int                                    _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 296 #define _KERNEL_TCB_TBITDEF_SUSCNT              : _KERNEL_TSK_TBIT_SUSCNT               /**< %jp{強制待ち要求ネスト数のビットフィールド宣言時の幅} */
 297 #endif
 298
 299 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 300
 301 #if (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 302 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 303 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 304 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 305 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 306 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 307 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 308 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 309 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 310 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 311 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 312 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 313 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 314 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 315 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 316 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 317 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 318 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 319 #elif (_KERNEL_TSK_TMAX_SUSCNT <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 320 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 321 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 322 #else
 323 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数を演算操作するときの型} */
 324 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_SUSCNT;                   /**< %jp{強制待ち要求ネスト数をTCBに格納するときの型} */
 325 #endif
 326 #define _KERNEL_TCB_TBITDEF_SUSCNT                                                                              /**< %jp{強制待ち要求ネスト数のビットフィールド宣言時の幅} */
 327
 328 #endif
 329
 330
 331 /*  %jp{タスクデータ}%en{Task data} */
 332 #if _KERNEL_TCB_BITFIELD                        /* %jp{TCBにビットフィールドを利用する場合} */
 333
 334 typedef VP_INT                                                  _KERNEL_TSK_T_DATA;
 335 typedef int                                                             _KERNEL_TCB_T_DATA;
 336 #define _KERNEL_TCB_TBITDEF_DATA                : _KERNEL_TSK_TBIT_DATA
 337
 338 #else                                                           /* %jp{TCBにビットフィールドを利用しない場合} */
 339
 340 typedef VP_INT                                                  _KERNEL_TSK_T_DATA;
 341 typedef VP_INT                                                  _KERNEL_TCB_T_DATA;
 342 #define _KERNEL_TCB_TBITDEF_DATA
 343
 344 #endif
 345
 346
 347 /*  %jp{エラーコード}%en{Error code} */
 348 #if _KERNEL_TCB_BITFIELD                        /* %jp{TCBにビットフィールドを利用する場合 */
 349
 350 typedef signed int                                              _KERNEL_TSK_T_ERCD;
 351 typedef signed int                                              _KERNEL_TCB_T_ERCD;
 352 #define _KERNEL_TCB_TBITDEF_ERCD                : _KERNEL_TSK_TBIT_ERCD
 353
 354 #else                                                           /* %jp{TCBにビットフィールドを利用しない場合} */
 355
 356 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_ERCD;
 357 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_ERCD;
 358 #define _KERNEL_TCB_TBITDEF_ERCD
 359
 360 #endif
 361
 362
 363 /* %jp{タスク属性}%en{Task attribute} */
 364 typedef ATR                                                             _KERNEL_TSK_T_TSKATR;
 365 typedef ATR                                                             _KERNEL_TCB_T_TSKATR;
 366 #define _KERNEL_TCB_TBITDEF_TSKATR
 367
 368
 369 /* %jp{タスク拡張情報}%jp{Extended information} */
 370 typedef VP_INT                                                  _KERNEL_TSK_T_EXINF;
 371 typedef VP_INT                                                  _KERNEL_TCB_T_EXINF;
 372 #define _KERNEL_TCB_TBITDEF_EXINF
 373
 374
 375 /* %jp{タスクの開始番地}%en{Start address} */
 376 typedef FP                                                              _KERNEL_TSK_T_TASK;
 377 typedef FP                                                              _KERNEL_TCB_T_TASK;
 378 #define _KERNEL_TCB_TBITDEF_TASK
 379
 380
 381 /* %jp{スタックサイズ}%en{Stack size} */
 382 typedef SIZE                                                    _KERNEL_TSK_T_STKSZ;
 383 typedef SIZE                                                    _KERNEL_TCB_T_STKSZ;
 384 #define _KERNEL_TCB_TBITDEF_STKSZ
 385
 386
 387 /* %jp{スタック領域の先頭番地}%en{Stack base address} */
 388 typedef VP                                                              _KERNEL_TSK_T_STK;
 389 typedef VP                                                              _KERNEL_TCB_T_STK;
 390 #define _KERNEL_TCB_TBITDEF_STK
 391
 392
 393 /* Initial stack pointer */
 394 typedef VP                                                              _KERNEL_TSK_T_ISP;
 395 typedef VP                                                              _KERNEL_TCB_T_ISP;
 396 #define _KERNEL_TCB_TBITDEF_ISP
 397
 398
 399
 400 /* %jp{相対時間}%en{Relative-Time} */
 401 #if _KERNEL_TCB_BITFIELD                /* %jp{TCBにビットフィールドを利用する場合} */
 402
 403 #if _KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE      /* %jp{符号付優先の場合1bit増やして符号付を使う} */
 404 typedef signed int                                              _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 405 typedef signed int                                              _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 406 #define _KERNEL_TCB_TBITDEF_RELTIM              : (_KERNEL_TSK_TBIT_RELTIM+1)   /**< %jp{相対時間のビットフィールド宣言時の幅} */
 407 #else
 408 typedef unsigned int                                    _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 409 typedef unsigned int                                    _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 410 #define _KERNEL_TCB_TBITDEF_RELTIM              : _KERNEL_TSK_TBIT_RELTIM               /**< %jp{相対時間のビットフィールド宣言時の幅} */
 411 #endif
 412
 413 #else                                                   /* %jp{TCBにビットフィールドを利用しない場合} */
 414
 415 #if (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_B) && _KERNEL_OPT_SIGNED_INT
 416 typedef _KERNEL_T_FAST_B                                _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 417 typedef _KERNEL_T_LEAST_B                               _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 418 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_UB) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 419 typedef _KERNEL_T_FAST_UB                               _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 420 typedef _KERNEL_T_LEAST_UB                              _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 421 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_H) && _KERNEL_OPT_SIGNED_INT
 422 typedef _KERNEL_T_FAST_H                                _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 423 typedef _KERNEL_T_LEAST_H                               _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 424 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_UH) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 425 typedef _KERNEL_T_FAST_UH                               _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 426 typedef _KERNEL_T_LEAST_UH                              _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 427 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_W) && _KERNEL_OPT_SIGNED_INT
 428 typedef _KERNEL_T_FAST_W                                _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 429 typedef _KERNEL_T_LEAST_W                               _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 430 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_UW) && !(_KERNEL_OPT_SIGNED_INT && !_KERNEL_OPT_CB_SIZE)
 431 typedef _KERNEL_T_FAST_UW                               _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 432 typedef _KERNEL_T_LEAST_UW                              _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 433 #elif (_KERNEL_TSK_TMAX_RELTIM <= _KERNEL_TMAX_D) && _KERNEL_OPT_SIGNED_INT
 434 typedef _KERNEL_T_FAST_D                                _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 435 typedef _KERNEL_T_LEAST_D                               _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 436 #else
 437 typedef _KERNEL_T_FAST_UD                               _KERNEL_TSK_T_RELTIM;                   /**< %jp{相対時間を演算操作するときの型} */
 438 typedef _KERNEL_T_LEAST_UD                              _KERNEL_TCB_T_RELTIM;                   /**< %jp{相対時間をTCBに格納するときの型} */
 439 #endif
 440 #define _KERNEL_TCB_TBITDEF_RELTIM                                                                              /**< %jp{相対時間のビットフィールド宣言時の幅} */
 441
 442 #endif
 443
 444
 445
 446 /* -------------------------------------------------------------------- */
 447 /*  TCB definetion                                                      */
 448 /* -------------------------------------------------------------------- */
 449
 450 #include "core/dsp.h"
 451 #include "core/que.h"
 452 #include "core/rdq.h"
 453 #include "core/toq.h"
 454 #include "core/sys.h"
 455
 456
 457
 458 /* -------------------------------------------------------------------- */
 459 /*  TCB definetion                                                      */
 460 /* -------------------------------------------------------------------- */
 461
 462 #if _KERNEL_TCB_SPLIT_RO
 463
 464 /** %jp{タスクコントロールブロック(ROM部)}%en{Task control block for ROM} */
 465 typedef struct _kernel_t_tcb_ro                         /* タスクコントロールブロック(ROM部) */
 466 {
 467 #if _KERNEL_TCB_TSKATR
 468         _KERNEL_TCB_T_TSKATR    tskatr          _KERNEL_TCB_TBITDEF_TSKATR;             /**< %jp{タスク属性}%en{Task attribute} */
 469 #endif
 470
 471 #if _KERNEL_TCB_EXINF
 472         _KERNEL_TCB_T_EXINF             exinf           _KERNEL_TCB_TBITDEF_EXINF;              /**< %jp{タスクの拡張情報}%en{Task extend information} */
 473 #endif
 474
 475 #if _KERNEL_TCB_TASK
 476         _KERNEL_TCB_T_TASK              task            _KERNEL_TCB_TBITDEF_TASK;               /**< %jp{タスクの起動番地}%en{Task start address} */
 477 #endif
 478
 479 #if _KERNEL_TCB_TSKPRI
 480         _KERNEL_TCB_T_TPRI              itskpri         _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクの起動時優先度}%en{Task initial priority} */
 481 #endif
 482
 483 #if _KERNEL_TCB_STKSZ
 484         _KERNEL_TCB_T_STKSZ             stksz           _KERNEL_TCB_TBITDEF_STKSZ;              /**< %jp{タスクのスタックのサイズ（バイト数）}%en{Task stack size(in bytes)} */
 485 #endif
 486
 487 #if _KERNEL_TCB_STK
 488         _KERNEL_TCB_T_STK               stk                     _KERNEL_TCB_TBITDEF_STK;                /**< %jp{タスクのスタック領域の先頭番地}%en{Base address of task stack space} */
 489 #endif
 490
 491 #if _KERNEL_TCB_ISP
 492         _KERNEL_TCB_T_ISP               isp                     _KERNEL_TCB_TBITDEF_ISP;                /**< %jp{スタックポインタの初期値}%en{Task initial stack pointer} */
 493 #endif
 494 } _KERNEL_T_TCB_RO;
 495
 496 typedef const _KERNEL_T_TCB_RO          *_KERNEL_T_TCB_RO_PTR;
 497
 498 /** %jp{タスクコントロールブロック(RAM部)}%en{Task control block for RAM} */
 499 typedef struct _kernel_t_tcb
 500 {
 501 #if _KERNEL_TCB_CTXCB
 502         _KERNEL_T_CTXCB                 ctxcb;                                                                          /**< %jp{タスクのコンテキスト}%en{Execution context control block} */
 503 #endif
 504
 505 #if _KERNEL_TCB_QUE
 506         _KERNEL_T_QUE                   *pk_que;                                                                        /**< %jp{属しているキュー}%en{Pointer of the queue for which the task connected} */
 507 #endif
 508
 509 #if _KERNEL_TCB_QUEOBJ
 510         _KERNEL_QUEOBJ                                                                                                          /**< %jp{キューに接続する為のオブジェクト}%en{Object for queue connection} */
 511 #endif
 512
 513 #if _KERNEL_TCB_TOQOBJ
 514         _KERNEL_TOQOBJ                                                                                                          /* %jp{タイムアウトキューに接続する為のオブジェクト}%en{Timeout queue object} */
 515 #endif
 516
 517 #if _KERNEL_TCB_TSKSTAT
 518         _KERNEL_TCB_T_TSKSTAT   tskstat         _KERNEL_TCB_TBITDEF_TSKSTAT;    /**< %jp{タスク状態}%en{Task state} */
 519 #endif
 520
 521 #if _KERNEL_TCB_TSKPRI
 522         _KERNEL_TCB_T_TPRI              tskpri          _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクの現在優先度}%en{Task current priority} */
 523 #endif
 524
 525 #if _KERNEL_TCB_TSKBPRI
 526         _KERNEL_TCB_T_TPRI              tskbpri         _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクのベース優先度}%en{Task base priority} */
 527 #endif
 528
 529 #if _KERNEL_TCB_TSKWAIT
 530         _KERNEL_TCB_T_TSKWAIT   tskwait         _KERNEL_TCB_TBITDEF_TSKWAIT;    /**< %jp{待ち要因}%en{Reason for waiting} */
 531 #endif
 532
 533 #if _KERNEL_TCB_WOBJID
 534         _KERNEL_TCB_T_WOBJID    wobjid          _KERNEL_TCB_TBITDEF_WOBJID;             /**< %jp{待ち対象のオブジェクトのID番号}%en{Object ID number for which the task waiting} */
 535 #endif
 536
 537 #if _KERNEL_TCB_ACTCNT
 538         _KERNEL_TCB_T_ACTCNT    actcnt          _KERNEL_TCB_TBITDEF_ACTCNT;             /**< %jp{起動要求キューイング回数}%en{Activation request count} */
 539 #endif
 540
 541 #if _KERNEL_TCB_WUPCNT
 542         _KERNEL_TCB_T_WUPCNT    wupcnt          _KERNEL_TCB_TBITDEF_WUPCNT;             /**< %jp{起床要求キューイング回数}%en{Wakeup request count} */
 543 #endif
 544
 545 #if _KERNEL_TCB_SUSCNT
 546         _KERNEL_TCB_T_SUSCNT    suscnt          _KERNEL_TCB_TBITDEF_SUSCNT;             /**< %jp{強制待ち要求ネスト回数}%en{Suspension count} */
 547 #endif
 548
 549
 550 #if _KERNEL_TCB_ERCD
 551         _KERNEL_TCB_T_ERCD              ercd            _KERNEL_TCB_TBITDEF_ERCD;               /**< %jp{待ち解除時のエラーコード}%en{error code} */
 552 #endif
 553
 554 #if _KERNEL_TCB_DATA
 555         _KERNEL_TCB_T_DATA              data            _KERNEL_TCB_TBITDEF_DATA;               /**< %jp{タスク同期時の受け渡しデータ}%en{task data} */
 556 #endif
 557
 558 #if _KERNEL_TCB_TSKID
 559         _KERNEL_TCB_T_TSKID             tskid           _KERNEL_TCB_TBITDEF_TSKID;              /**< %jp{タスクID番号の逆引き用}%en{Task object ID} */
 560 #endif
 561
 562
 563 /* %jp{ポインタ管理時にROM部/RAM部を分離する場合はポインタを張る} */
 564 #if _KERNEL_TCB_ALGORITHM == _KERNEL_TCB_ALG_PTRARRAY
 565         const _KERNEL_T_TCB_RO  *tcb_ro;
 566 #endif
 567 } _KERNEL_T_TCB;
 568
 569 typedef _KERNEL_T_TCB                   *_KERNEL_T_TCB_PTR;
 570
 571
 572 #else
 573
 574
 575 /** %jp{タスクコントロールブロック}%en{Task Control Block} */
 576 typedef struct _kernel_t_tcb
 577 {
 578 #if _KERNEL_TCB_CTXCB
 579         _KERNEL_T_CTXCB                 ctxcb;                                                                          /**< %jp{タスクのコンテキスト}%en{Execution context control block} */
 580 #endif
 581
 582 #if _KERNEL_TCB_QUE
 583         _KERNEL_T_QUE                   *pk_que;                                                                        /**< %jp{属しているキュー}%en{Pointer of the queue for which the task connected} */
 584 #endif
 585
 586 #if _KERNEL_TCB_QUEOBJ
 587         _KERNEL_QUEOBJ                                                                                                          /**< %jp{キューに接続する為のオブジェクト}%en{Object for queue connection} */
 588 #endif
 589
 590 #if _KERNEL_TCB_TOQOBJ
 591         _KERNEL_TOQOBJ                                                                                                          /**< %jp{タイムアウトキューに接続する為のオブジェクト}%en{Timeout queue object} */
 592 #endif
 593
 594 #if _KERNEL_TCB_TSKSTAT
 595         _KERNEL_TCB_T_TSKSTAT   tskstat         _KERNEL_TCB_TBITDEF_TSKSTAT;    /**< %jp{タスク状態}%en{Task state} */
 596 #endif
 597
 598 #if _KERNEL_TCB_TSKPRI
 599         _KERNEL_TCB_T_TPRI              tskpri          _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクの現在優先度}%en{Task current priority} */
 600 #endif
 601
 602 #if _KERNEL_TCB_TSKBPRI
 603         _KERNEL_TCB_T_TPRI              tskbpri         _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクのベース優先度}%en{Task base priority} */
 604 #endif
 605
 606 #if _KERNEL_TCB_TSKWAIT
 607         _KERNEL_TCB_T_TSKWAIT   tskwait         _KERNEL_TCB_TBITDEF_TSKWAIT;    /**< %jp{待ち要因}%en{Reason for waiting} */
 608 #endif
 609
 610 #if _KERNEL_TCB_WOBJID
 611         _KERNEL_TCB_T_WOBJID    wobjid          _KERNEL_TCB_TBITDEF_WOBJID;             /**< %jp{待ち対象のオブジェクトのID番号}%en{Object ID number for which the task waiting} */
 612 #endif
 613
 614 #if _KERNEL_TCB_ACTCNT
 615         _KERNEL_TCB_T_ACTCNT    actcnt          _KERNEL_TCB_TBITDEF_ACTCNT;             /**< %jp{起動要求キューイング回数}%en{Activation request count} */
 616 #endif
 617
 618 #if _KERNEL_TCB_WUPCNT
 619         _KERNEL_TCB_T_WUPCNT    wupcnt          _KERNEL_TCB_TBITDEF_WUPCNT;             /**< %jp{起床要求キューイング回数}%en{Wakeup request count} */
 620 #endif
 621
 622 #if _KERNEL_TCB_SUSCNT
 623         _KERNEL_TCB_T_SUSCNT    suscnt          _KERNEL_TCB_TBITDEF_SUSCNT;             /**< %jp{強制待ち要求ネスト回数}%en{Suspension count} */
 624 #endif
 625
 626
 627 #if _KERNEL_TCB_ERCD
 628         _KERNEL_TCB_T_ERCD              ercd            _KERNEL_TCB_TBITDEF_ERCD;               /**< %jp{待ち解除時のエラーコード}%en{error code} */
 629 #endif
 630
 631 #if _KERNEL_TCB_DATA
 632         _KERNEL_TCB_T_DATA              data            _KERNEL_TCB_TBITDEF_DATA;               /**< %jp{タスク同期時の受け渡しデータ}%en{task data} */
 633 #endif
 634
 635 #if _KERNEL_TCB_TSKID
 636         _KERNEL_TCB_T_TSKID             tskid           _KERNEL_TCB_TBITDEF_TSKID;              /**< %jp{タスクID番号の逆引き用}%en{Task object ID} */
 637 #endif
 638
 639
 640 #if _KERNEL_TCB_TSKATR
 641         _KERNEL_TCB_T_TSKATR    tskatr          _KERNEL_TCB_TBITDEF_TSKATR;             /**< %jp{タスク属性}%en{Task attribute} */
 642 #endif
 643
 644 #if _KERNEL_TCB_EXINF
 645         _KERNEL_TCB_T_EXINF             exinf           _KERNEL_TCB_TBITDEF_EXINF;              /**< %jp{タスクの拡張情報}%en{Task extend information} */
 646 #endif
 647
 648 #if _KERNEL_TCB_TASK
 649         _KERNEL_TCB_T_TASK              task            _KERNEL_TCB_TBITDEF_TASK;               /**< %jp{タスクの起動番地}%en{Task start address} */
 650 #endif
 651
 652 #if _KERNEL_TCB_ITSKPRI
 653         _KERNEL_TCB_T_TPRI              itskpri         _KERNEL_TCB_TBITDEF_TPRI;               /**< %jp{タスクの起動時優先度}%en{Task initial priority} */
 654 #endif
 655
 656 #if _KERNEL_TCB_STKSZ
 657         _KERNEL_TCB_T_STKSZ             stksz           _KERNEL_TCB_TBITDEF_STKSZ;              /**< %jp{タスクのスタックのサイズ（バイト数）}%en{Task stack size(in bytes)} */
 658 #endif
 659
 660 #if _KERNEL_TCB_STK
 661         _KERNEL_TCB_T_STK               stk                     _KERNEL_TCB_TBITDEF_STK;                /**< %jp{タスクのスタック領域の先頭番地}%en{Base address of task stack space} */
 662 #endif
 663
 664 #if _KERNEL_TCB_ISP
 665         _KERNEL_TCB_T_ISP               isp                     _KERNEL_TCB_TBITDEF_ISP;                /**< %jp{スタックポインタの初期値}%en{Task initial stack pointer} */
 666 #endif
 667 } _KERNEL_T_TCB;
 668
 669 typedef _KERNEL_T_TCB                           _KERNEL_T_TCB_RO;
 670 typedef const _KERNEL_T_TCB_RO          *_KERNEL_T_TCB_RO_PTR;
 671 typedef _KERNEL_T_TCB                           *_KERNEL_T_TCB_PTR;
 672
 673 #endif
 674
 675
 676
 677 /* ------------------------------------------ */
 678 /*  ID range                                  */
 679 /* ------------------------------------------ */
 680
 681 extern const ID                                                 _kernel_max_tskid;                                                                              /**< %jp{タスクIDの最大値} */
 682
 683 #define _KERNEL_TSK_TMIN_ID                             1                                                                                                               /**< %jp{タスクIDの最小値} */
 684 #define _KERNEL_TSK_TMAX_ID                             (_kernel_max_tskid)                                                                             /**< %jp{タスクIDの最大値} */
 685
 686 #define _KERNEL_TSK_CHECK_TSKID(tskid)  ((tskid) >= _KERNEL_TSK_TMIN_ID && (tskid) <= _KERNEL_TSK_TMAX_ID)
 687                                                                                                                                                                                                 /**< %jp{ID範囲チェック} */
 688
 689
 690 /* ------------------------------------------ */
 691 /*  Control block tables                      */
 692 /* ------------------------------------------ */
 693
 694 #if _KERNEL_TCB_ALGORITHM == _KERNEL_TCB_ALG_BLKARRAY
 695 #if _KERNEL_TCB_SPLIT_RO
 696
 697 /* %jp{ブロック配列管理でRO分離の場合}%en{block array} */
 698 extern  _KERNEL_T_TCB                                   _kernel_tcb_tbl[];                                                                              /**< %jp{タスクコントロールブロックテーブル} */
 699 extern const _KERNEL_T_TCB_RO                   _kernel_tcb_ro_tbl[];                                                                   /**< %jp{タスクコントロールブロック(リードオンリー部)テーブル} */
 700 #define _KERNEL_TSK_ID2TCB(tskid)               (&_kernel_tcb_tbl[(tskid) - _KERNEL_TSK_TMIN_ID])               /**< %jp{コントロールブロックの取得} */
 701 #define _KERNEL_TSK_CHECK_EXS(tskid)    (_kernel_tcb_ro_tbl[(tskid) - _KERNEL_TSK_TMIN_ID].task != NULL)
 702                                                                                                                                                                                                 /**< %jp{オブジェクトの存在チェック} */
 703
 704 #else
 705
 706 /* %jp{ブロック配列管理の場合}%en{block array} */
 707 extern  _KERNEL_T_TCB                                   _kernel_tcb_tbl[];                                                                              /**< %jp{タスクコントロールブロックテーブル} */
 708 #define _KERNEL_TSK_ID2TCB(tskid)               (&_kernel_tcb_tbl[(tskid) - _KERNEL_TSK_TMIN_ID])               /**< %jp{コントロールブロックの取得} */
 709 #define _KERNEL_TSK_CHECK_EXS(tskid)    (_kernel_tcb_tbl[(tskid) - _KERNEL_TSK_TMIN_ID].task != NULL)
 710                                                                                                                                                                                                 /**< %jp{オブジェクトの存在チェック} */
 711
 712 #endif
 713
 714 #elif _KERNEL_TCB_ALGORITHM == _KERNEL_TCB_ALG_PTRARRAY
 715
 716 /* %jp{ポインタ配列管理の場合}%en{pointer array} */
 717 extern  _KERNEL_T_TCB                                   *_kernel_tcb_tbl[];                                                                             /**< %jp{タスクコントロールブロックテーブル} */
 718 #define _KERNEL_TSK_ID2TCB(tskid)               (_kernel_tcb_tbl[(tskid) - _KERNEL_TMIN_TSKID])                 /**< %jp{タスクIDからTCB アドレスを取得} */
 719 #define _KERNEL_TSK_CHECK_EXS(tskid)    (_KERNEL_TSK_ID2TCB(tskid) != NULL)                                             /**< %jp{オブジェクトの存在チェック} */
 720
 721 #endif
 722
 723
 724
 725
 726 /* ------------------------------------------ */
 727 /*  Convert Handle                            */
 728 /* ------------------------------------------ */
 729
 730 #if _KERNEL_TSKHDL_ID           /* %en{TSKHDL is ID}%jp{タスクポインタにIDを使う} */
 731
 732 #define _KERNEL_TSK_ID2TSKHDL(tskid)            (tskid)
 733 #define _KERNEL_TSK_TSKHDL2ID(tskhdl)           (tskhdl)
 734 #define _KERNEL_TSK_TCB2TSKHDL(tcb)                     _KERNEL_TSK_TCB2ID(tcb)
 735 #define _KERNEL_TSK_TSKHDL2TCB(tskhdl)          _KERNEL_TSK_ID2TCB(tskhdl)
 736 #define _KERNEL_TSK_GET_TSKHDL(tskid, tcb)      (tskid)
 737
 738 #else                                           /* %en{TSKHDL is Address of TCB}%jp{タスクポインタにTCBのアドレスを使う} */
 739
 740 #define _KERNEL_TSK_ID2TSKHDL(tskid)            _KERNEL_TSK_ID2TCB(tskid)
 741 #define _KERNEL_TSK_TSKHDL2ID(tskhdl)           _KERNEL_TSK_TCB2ID(tskhdl)
 742 #define _KERNEL_TSK_TCB2TSKHDL(tskhdl)          (tskhdl)
 743 #define _KERNEL_TSK_TSKHDL2TCB(tskhdl)          (tskhdl)
 744 #define _KERNEL_TSK_GET_TSKHDL(tskid, tcb)      (tcb)
 745
 746 #endif
 747
 748
 749 /* ------------------------------------------ */
 750 /*   Accessor for TCB                         */
 751 /* ------------------------------------------ */
 752
 753 /* tcb_ro */
 754 #if !_KERNEL_TCB_SPLIT_RO
 755 #define _KERNEL_TSK_GET_TCB_RO(tskid, tcb)      (tcb)
 756 #else
 757 #if _KERNEL_TCB_ALGORITHM == _KERNEL_TCB_ALG_BLKARRAY           /* %jp{TCBを単純配列で管理}%en{array of block} */
 758 #define _KERNEL_TSK_GET_TCB_RO(tskid, tcb)      (&_kernel_tcb_ro_tbl[(tskid)])
 759 #elif _KERNEL_TCB_ALGORITHM == _KERNEL_TCB_ALG_PTRARRAY         /* %jp{TCBをポインタ配列で管理}%en{array of pointer} */
 760 #define _KERNEL_TSK_GET_TCB_RO(tskid, tcb)      ((tcb)->tcb_ro)
 761 #endif
 762 #endif
 763
 764
 765 /* ctxcb */
 766 #define _KERNEL_TSK_GET_CTXCB(tcb)                      (&(tcb)->ctxcb)
 767
 768 /* que */
 769 #if _KERNEL_TCB_QUE
 770 #define _KERNEL_TSK_SET_QUE(tcb, x)                     do { (tcb)->pk_que = (_KERNEL_T_QUE *)(x); } while(0)
 771 #define _KERNEL_TSK_GET_QUE(tcb)                        ((_KERNEL_T_QUE *)(tcb)->pk_que)
 772 #else   /* %jp{TCBに所属キューの情報を持たせない場合は別情報からの探索で求める} */
 773 #define _KERNEL_TSK_SET_QUE(tcb, x)                     do { } while(0)
 774 #define _KERNEL_TSK_GET_QUE(tcb)                        _kernel_get_que(tcb)
 775 #endif
 776
 777 /* tskstat */
 778 #if _KERNEL_TCB_TSKSTAT
 779 #define _KERNEL_TSK_SET_TSKSTAT(tcb, x)         do { (tcb)->tskstat = (_KERNEL_TCB_T_TSKSTAT)(x); } while(0)
 780 #define _KERNEL_TSK_GET_TSKSTAT(tcb)            ((_KERNEL_TSK_T_TSKSTAT)(tcb)->tskstat)
 781 #else
 782 #define _KERNEL_TSK_SET_TSKSTAT(tcb, x)         do { } while(0)
 783 #define _KERNEL_TSK_GET_TSKSTAT(tcb)            0
 784 #endif
 785
 786 /* tskpri */
 787 #if _KERNEL_TCB_TSKPRI  /* %jp{通常のTCBへのアクセサ} */
 788 #define _KERNEL_TSK_SET_TSKPRI(tcb, x)          do { (tcb)->tskpri = (x); } while(0)
 789 #define _KERNEL_TSK_GET_TSKPRI(tcb)                     ((tcb)->tskpri)
 790 #else
 791 #if _KERNEL_TCB_ITSKPRI /* %jp{優先度固定(ROM配置)時のアクセサ} */
 792 #define _KERNEL_TSK_SET_TSKPRI(tcb, x)          do { } while(0)
 793 #define _KERNEL_TSK_GET_TSKPRI(tcb)                     ((tcb)->itskpri)
 794 #else                                   /* %jp{優先度未使用時(全てFIFO順)は1に固定する} */
 795 #define _KERNEL_TSK_SET_TSKPRI(tcb, x)          do { } while(0)
 796 #define _KERNEL_TSK_GET_TSKPRI(tcb)                     (1)
 797 #endif
 798 #endif
 799
 800 /* tskbpri */
 801 #if _KERNEL_TCB_TSKBPRI
 802 #define _KERNEL_TSK_SET_TSKBPRI(tcb, x)         do { (tcb)->tskbpri = (x); } while(0)
 803 #define _KERNEL_TSK_GET_TSKBPRI(tcb)            ((tcb)->tskbpri)
 804 #else
 805 #define _KERNEL_TSK_SET_TSKBPRI(tcb, x)         do { } while(0)
 806 #define _KERNEL_TSK_GET_TSKBPRI(tcb)            _KERNEL_TSK_GET_TSKPRI(tcb)
 807 #endif
 808
 809 /* tskwait */
 810 #if _KERNEL_TCB_TSKWAIT
 811 #define _KERNEL_TSK_SET_TSKWAIT(tcb, x)         do { (tcb)->tskwait = (x); } while(0)
 812 #define _KERNEL_TSK_GET_TSKWAIT(tcb)            ((tcb)->tskwait)
 813 #else
 814 #define _KERNEL_TSK_SET_TSKWAIT(tcb, x)         do { } while(0)
 815 #define _KERNEL_TSK_GET_TSKWAIT(tcb)            (0)
 816 #endif
 817
 818 /* wobjid */
 819 #if _KERNEL_TCB_WOBJID
 820 #define _KERNEL_TSK_SET_WOBJID(tcb, x)          do { (tcb)->wobjid = (x); } while(0)
 821 #define _KERNEL_TSK_GET_WOBJID(tcb)                     ((tcb)->wobjid)
 822 #else
 823 #define _KERNEL_TSK_SET_WOBJID(tcb, x)          do { } while(0)
 824 #define _KERNEL_TSK_GET_WOBJID(tcb)                     (0)
 825 #endif
 826
 827 /* actcnt */
 828 #if _KERNEL_TCB_ACTCNT
 829 #define _KERNEL_TSK_SET_ACTCNT(tcb, x)          do { (tcb)->actcnt = (x); } while(0)
 830 #define _KERNEL_TSK_GET_ACTCNT(tcb)                     ((tcb)->actcnt)
 831 #else
 832 #define _KERNEL_TSK_SET_ACTCNT(tcb, x)          do { } while(0)
 833 #define _KERNEL_TSK_GET_ACTCNT(tcb)                     (0)
 834 #endif
 835
 836 /* wupcnt */
 837 #if _KERNEL_TCB_WUPCNT
 838 #define _KERNEL_TSK_SET_WUPCNT(tcb, x)          do { (tcb)->wupcnt = (x); } while(0)
 839 #define _KERNEL_TSK_GET_WUPCNT(tcb)                     ((tcb)->wupcnt)
 840 #else
 841 #define _KERNEL_TSK_SET_WUPCNT(tcb, x)          do { } while(0)
 842 #define _KERNEL_TSK_GET_WUPCNT(tcb)                     (0)
 843 #endif
 844
 845 /* suscnt */
 846 #if _KERNEL_TCB_SUSCNT
 847 #define _KERNEL_TSK_SET_SUSCNT(tcb, x)          do { (tcb)->suscnt = (x); } while(0)
 848 #define _KERNEL_TSK_GET_SUSCNT(tcb)                     ((tcb)->suscnt)
 849 #else
 850 #define _KERNEL_TSK_SET_SUSCNT(tcb, x)          do { } while(0)
 851 #define _KERNEL_TSK_GET_SUSCNT(tcb)                     (0)
 852 #endif
 853
 854 /* ercd */
 855 #if _KERNEL_TCB_ERCD
 856 #define _KERNEL_TSK_SET_ERCD(tcb, x)            do { (tcb)->ercd = (x); } while(0)
 857 #define _KERNEL_TSK_GET_ERCD(tcb)                       ((tcb)->ercd)
 858 #else
 859 #define _KERNEL_TSK_SET_ERCD(tcb, x)            do { } while(0)
 860 #define _KERNEL_TSK_GET_ERCD(tcb)                       (E_OK)
 861 #endif
 862
 863 /* data */
 864 #if _KERNEL_TCB_DATA
 865 #define _KERNEL_TSK_SET_DATA(tcb, x)            do { (tcb)->data = (x); } while(0)
 866 #define _KERNEL_TSK_GET_DATA(tcb)                       ((tcb)->data)
 867 #else
 868 #define _KERNEL_TSK_SET_DATA(tcb, x)            do { } while(0)
 869 #define _KERNEL_TSK_GET_DATA(tcb)                       (0)
 870 #endif
 871
 872
 873 /* tskid */
 874 #if _KERNEL_TCB_TSKID
 875 #define _KERNEL_TSK_SET_TSKID(tcb_ro, x)        do { (tcb_ro)->tskid = (x); } while(0)
 876 #define _KERNEL_TSK_GET_TSKID(tcb_ro)           ((tcb_ro)->tskid)
 877 #else
 878 #define _KERNEL_TSK_SET_TSKID(tcb_ro, x)        do { } while(0)
 879 #define _KERNEL_TSK_GET_TSKID(tcb_ro)           (0)
 880 #endif
 881
 882 /* tskatr */
 883 #if _KERNEL_TCB_TSKATR
 884 #define _KERNEL_TSK_SET_TSKATR(tcb_ro, x)       do { (tcb_ro)->tskatr = (x); } while(0)
 885 #define _KERNEL_TSK_GET_TSKATR(tcb_ro)          ((tcb_ro)->tskatr)
 886 #else   /* %jp{tskatr未使用時はTA_HLNGに固定する} */
 887 #define _KERNEL_TSK_SET_TSKATR(tcb_ro, x)       do { } while(0)
 888 #define _KERNEL_TSK_GET_TSKATR(tcb_ro)          (TA_HLNG)
 889 #endif
 890
 891 /* exinf */
 892 #if _KERNEL_TCB_EXINF
 893 #define _KERNEL_TSK_SET_EXINF(tcb_ro, x)        do { (tcb_ro)->exinf = (x); } while(0)
 894 #define _KERNEL_TSK_GET_EXINF(tcb_ro)           ((tcb_ro)->exinf)
 895 #else
 896 #define _KERNEL_TSK_SET_EXINF(tcb_ro, x)        do { } while(0)
 897 #define _KERNEL_TSK_GET_EXINF(tcb_ro)           (0)
 898 #endif
 899
 900 /* task */
 901 #if _KERNEL_TCB_TASK
 902 #define _KERNEL_TSK_SET_TASK(tcb_ro, x)         do { (tcb_ro)->task = (x); } while(0)
 903 #define _KERNEL_TSK_GET_TASK(tcb_ro)            ((tcb_ro)->task)
 904 #else
 905 #define _KERNEL_TSK_SET_TASK(tcb_ro, x)         do { } while(0)
 906 #define _KERNEL_TSK_GET_TASK(tcb_ro)            (0)
 907 #endif
 908
 909 /* tskipri */
 910 #if _KERNEL_TCB_ITSKPRI
 911 #define _KERNEL_TSK_SET_ITSKPRI(tcb_ro, x)      do { (tcb_ro)->itskpri = (x); } while(0)
 912 #define _KERNEL_TSK_GET_ITSKPRI(tcb_ro)         ((tcb_ro)->itskpri)
 913 #else   /* %jp{tskatr未使用時はTA_HLNGに固定する} */
 914 #define _KERNEL_TSK_SET_ITSKPRI(tcb_ro, x)      do { } while(0)
 915 #define _KERNEL_TSK_GET_ITSKPRI(tcb_ro)         (1)
 916 #endif
 917
 918 /* stksz */
 919 #if _KERNEL_TCB_STKSZ
 920 #define _KERNEL_TSK_SET_STKSZ(tcb_ro, x)        do { (tcb_ro)->stksz = (x); } while(0)
 921 #define _KERNEL_TSK_GET_STKSZ(tcb_ro)           ((tcb_ro)->stksz)
 922 #else
 923 #define _KERNEL_TSK_SET_STKSZ(tcb_ro, x)        do { } while(0)
 924 #define _KERNEL_TSK_GET_STKSZ(tcb_ro)           (0)
 925 #endif
 926
 927 /* stk */
 928 #if _KERNEL_TCB_STK
 929 #define _KERNEL_TSK_SET_STK(tcb_ro, x)          do { (tcb_ro)->stk = (x); } while(0)
 930 #define _KERNEL_TSK_GET_STK(tcb_ro)                     ((tcb_ro)->stk)
 931 #else
 932 #define _KERNEL_TSK_SET_STK(tcb_ro, x)          do { } while(0)
 933 #define _KERNEL_TSK_GET_STK(tcb_ro)                     (0)
 934 #endif
 935
 936 /* isp */
 937 #if _KERNEL_TCB_ISP
 938 #define _KERNEL_TSK_SET_ISP(tcb_ro, x)          do { (tcb_ro)->isp = (x); } while(0)
 939 #define _KERNEL_TSK_GET_ISP(tcb_ro)                     ((tcb_ro)->isp)
 940 #else
 941 #define _KERNEL_TSK_SET_ISP(tcb_ro, x)          do { } while(0)
 942 #define _KERNEL_TSK_GET_ISP(tcb_ro)                     ((VP)((UB *)_KERNEL_TSK_GET_STK(tcb_ro) + _KERNEL_TSK_GET_STKSZ(tcb_ro)))
 943 #endif
 944
 945
 946 /* ------------------------------------------ */
 947 /*   Macro functions                          */
 948 /* ------------------------------------------ */
 949
 950 #if _KERNEL_TCB_TSKSTAT
 951 #define _KERNEL_TSK_SNS_RDY(tcb)        (_KERNEL_TSK_GET_TSKSTAT(tcb) == _KERNEL_TTS_RDY)
 952 #define _KERNEL_TSK_SNS_WAI(tcb)        (_KERNEL_TSK_GET_TSKSTAT(tcb) & _KERNEL_TTS_WAI)
 953 #define _KERNEL_TSK_SNS_SUS(tcb)        (_KERNEL_TSK_GET_TSKSTAT(tcb) & _KERNEL_TTS_SUS)
 954 #else
 955 #define _KERNEL_TSK_SNS_RDY(tcb)        ()
 956 #define _KERNEL_TSK_SNS_WAI(tcb)        ()
 957 #define _KERNEL_TSK_SNS_SUS(tcb)        (_KERNEL_TSK_GET_SUSCNT(tcb) > 0)
 958 #endif
 959
 960
 961 #ifdef __cplusplus
 962 extern "C" {
 963 #endif
 964
 965 ER _kernel_cre_tsk(ID tskid, const T_CTSK *pk_ctsk);
 966
 967 #ifdef __cplusplus
 968 }
 969 #endif
 970
 971
 972
 973 #endif  /* _KERNEL__object__tskobj_h__ */
 974
 975
 976
 977 /* end of file */