Commit: 2c0ddf8d753e97d2fde5def6ebc1e5c092b98b06 - it3 (git)

uITRON3のシステムコールをシュミレーションする、uITRON3向けモジュールの単体テスト用ライブラリ。

Commit MetaInfo

• Revision: 2c0ddf8d753e97d2fde5def6ebc1e5c092b98b06 (tree)
• Time: 2013-03-31 09:25:17
• Author: nikarana <nikarana@gmai...>
• Commiter: nikarana

Log Message

add c files.

Change Summary

• add: src/alm.c
• add: src/alm.h
• add: src/cyc.c
• add: src/cyc.h
• add: src/depend/depend.h
• add: src/depend/win32/depend_win32.c
• add: src/depend/win32/depend_win32.h
• add: src/flg.c
• add: src/flg.h
• add: src/int.c
• add: src/int.h
• add: src/it3.c
• add: src/it3_common.h
• add: src/it3_config.h
• add: src/it3_debug.c
• add: src/it3_debug.h
• add: src/kernel.h
• add: src/kernel_etc.c
• add: src/lst.h
• add: src/mbf.c
• add: src/mbf.h
• add: src/mbx.c
• add: src/mbx.h
• add: src/mpf.c
• add: src/mpf.h
• add: src/mpl.c
• add: src/mpl.h
• add: src/net.c
• add: src/net.h
• add: src/por.c
• add: src/por.h
• add: src/que_ctl.c
• add: src/que_ctl.h
• add: src/sem.c
• add: src/sem.h
• add: src/sys.c
• add: src/sys.h
• add: src/tim.c
• add: src/tim.h
• add: src/tsk.c
• add: src/tsk.h

Incremental Difference

--- /dev/null
+++ b/src/alm.c
@@ -0,0 +1,225 @@
+/**
+ * @file	alm.c
+ * @brief	時間管理機能（アラーム）
+ *
+ * @author  nikarana
+ * @date    2012/11/23
+ *
+ */
+
+#include "alm.h"
+#include "it3_common.h"
+#include "it3_config.h"
+#include <depend.h>
+
+#define	ISVALID_ALMNO(almno)	((0 < (almno)) && ((almno) < TNUM_ALM))
+#define	ISVALID_ALMATR(almatr)	(TRUE) /* 属性情報はチェックしない */
+
+/* アラームハンドラ管理構造体 */
+typedef struct S_ALMCB
+{
+	HNO			almno;							/**< アラームハンドラ番号		*/
+
+	VP			exinf;							/**< 拡張情報				*/
+	ATR			almatr;							/**< アラームハンドラ属性		*/
+	FP			almhdr;							/**< アラームハンドラアドレス	*/
+	UINT		tmmode;							/**< 起動時刻指定モード		*/
+	ALMTIME		almtim;							/**< ハンドラ起動時刻			*/
+
+	ALMTIME		lfttim;							/**< 						*/
+
+	UW			time;							/**< ハンドラ起動時間			*/
+	FP			hdr;							/**< アラームハンドラ			*/
+
+} T_ALMCB;
+
+static const T_ALMCB almcb_initializer = {0};
+
+extern SYSTIME systime;
+
+static T_ALMCB almcbs[TNUM_ALM];
+
+/**
+ * @brief	時間管理機能（アラーム）初期化処理
+ *
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ */
+ER alm_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_ALM;cnt++)
+	{
+		almcbs[cnt] = almcb_initializer;
+	}
+
+	return E_OK;
+}
+
+/**
+ * @brief	時間管理機能（アラーム）終了処理
+ */
+void alm_terminate(void)
+{
+}
+
+/**
+ * @brief	時間管理機能（アラーム）初期化処理
+ *
+ * @param	steptime	経過時間(ms)
+ */
+void alm_timeevent(UW steptime)
+{
+	INT cnt;
+	T_ALMCB *p_almcb;
+
+	for(cnt = 0;cnt < TNUM_ALM;cnt++)
+	{
+		p_almcb = &(almcbs[cnt]);
+
+		depend_EnterCriticalSection();
+
+		if(ISVALID_PTR(p_almcb->almhdr))
+		{
+			if(steptime < p_almcb->time)
+			{
+				p_almcb->time -= steptime;
+			}
+			else
+			{
+				(p_almcb->almhdr)();
+
+				*p_almcb = almcb_initializer;
+			}
+		}
+
+		depend_LeaveCriticalSection();
+	}
+}
+
+/**
+ * @brief	アラームハンドラ定義
+ *
+ * @param	almno	アラームハンドラ指定番号
+ * @param	pk_dalm	アラームハンドラ定義情報
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOMEM	メモリ不足(管理ブロック用の領域が確保できない)
+ * @retval	E_RSATR	予約属性(almatrが不正あるいは利用できない)
+ * @retval	E_PAR	パラメータエラー(almno, pk_dalm, almhdr, tmmode, almtimが不正あるいは利用できない)
+ */
+ER def_alm(HNO almno, T_DALM *pk_dalm)
+{
+	ER result;
+
+	if(ISVALID_ALMNO(almno))
+	{
+		T_ALMCB *p_almcb;
+
+		p_almcb = &(almcbs[almno]);
+
+		depend_EnterCriticalSection();
+
+		if(ISVALID_PTR(pk_dalm))
+		{
+			if(ISVALID_ALMATR(pk_dalm->almatr))
+			{
+				if((TTM_ABS == pk_dalm->tmmode) || (TTM_REL == pk_dalm->tmmode))
+				{
+					if(! ((TTM_REL == pk_dalm->tmmode) && (pk_dalm->almtim.ltime < 0)))
+					{
+						*p_almcb = almcb_initializer;
+
+						p_almcb->almno = almno;
+
+						p_almcb->exinf = pk_dalm->exinf;
+						p_almcb->almatr = pk_dalm->almatr;
+						p_almcb->almhdr = pk_dalm->almhdr;
+						p_almcb->tmmode = pk_dalm->tmmode;
+						p_almcb->almtim = pk_dalm->almtim;
+
+						p_almcb->hdr = pk_dalm->almhdr;
+						p_almcb->time = pk_dalm->almtim.ltime;
+						if(TTM_ABS == pk_dalm->tmmode)
+						{
+							p_almcb->time += systime.ltime;
+						}
+
+						result = E_OK;;
+					}
+					else
+					{
+						result = E_PAR;
+					}
+				}
+				else
+				{
+					result = E_PAR;
+				}
+			}
+			else
+			{
+				result = E_RSATR;
+			}
+		}
+		else
+		{
+			*p_almcb = almcb_initializer;
+
+			result = E_OK;;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	アラームハンドラ状態参照
+ *
+ * @param	pk_ralm	アラームハンドラの状態を返すパケットの先頭アドレス
+ * @param	almno	アラームハンドラ指定番号
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOEXS	オブジェクトが存在していない(almnoのアラームハンドラが定義されていない)
+ * @retval	E_PAR	パラメータエラー(almnoが利用できない, リターンパラメータ用のパケットアドレスが使用できない値)
+ */
+ER ref_alm(T_RALM *pk_ralm, HNO almno)
+{
+	ER result;
+
+	if(ISVALID_ALMNO(almno) && ISVALID_PTR(pk_ralm))
+	{
+		T_ALMCB *p_almcb;
+
+		p_almcb = &(almcbs[almno]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_almcb->almno)
+		{
+			pk_ralm->exinf = p_almcb->exinf;
+			pk_ralm->lfttim = p_almcb->lfttim;	// TODO どうしよっかなー
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/alm.h
@@ -0,0 +1,18 @@
+#ifndef _ALM_H_
+#define _ALM_H_
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif /* defined(__cplusplus) */
+
+#include <itron.h>
+
+ER alm_initialize(void);
+void alm_terminate(void);
+void alm_timeevent(UW steptime);
+
+#if	defined(__cplusplus)
+}
+#endif /* defined(__cplusplus) */
+
+#endif /* _ALM_H_ */

--- /dev/null
+++ b/src/cyc.c
@@ -0,0 +1,255 @@
+/**
+ * @file	cyc.c
+ * @brief	時間管理機能（周期起動）
+ *
+ * @author  nikarana
+ * @date    2012/11/23
+ *
+ */
+
+#include "cyc.h"
+#include "it3_common.h"
+#include "it3_config.h"
+#include <depend.h>
+
+#define	ISVALID_CYCNO(cycno)	((0 < (cycno)) && ((cycno) < TNUM_CYC))
+#define	ISVALID_CYCACT(cycact)	(0 == ((cycact) & ~(TCY_INI | TCY_ON)))
+
+typedef struct S_CYCCB
+{
+	HNO			cycno;							/**< 周期起動ハンドラ番号				*/
+
+	VP			exinf;							/**< 拡張情報						*/
+	ATR			cycatr;							/**< 周期起動ハンドラ属性				*/
+	FP			cychdr;							/**< 周期起動ハンドラアドレス			*/
+	UINT		cycact;							/**< 周期起動ハンドラ活性状態			*/
+	CYCTIME		cyctim;							/**< 周期起動時間間隔					*/
+
+	UINT		lftime;							/**< 次のハンドラ起動までの残り時間 */
+	UINT		cytime;							/**< 周期起動時間間隔 */
+} T_CYCCB;
+
+static const T_CYCCB cyccb_initializer = {0};
+
+static T_CYCCB cyccbs[TNUM_CYC];
+
+/**
+ * @brief	時間管理機能（周期起動）初期化処理
+ *
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_OK以外	異常終了
+ */
+ER cyc_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_CYC;cnt++)
+	{
+		cyccbs[cnt] = cyccb_initializer;
+	}
+
+	return E_OK;
+}
+
+/**
+ * @brief	時間管理機能（周期起動）終了処理
+ */
+void cyc_terminate(void)
+{
+}
+
+/**
+ * @brief	周期起動タイマイベント
+ *
+ * @param	steptime	経過時間(ms)
+ */
+void cyc_timeevent(UINT steptime)
+{
+	INT cnt;
+	T_CYCCB *p_cyccb;
+
+	for(cnt = 0;cnt < TNUM_CYC;cnt++)
+	{
+		p_cyccb = &(cyccbs[cnt]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_cyccb->cycno)
+		{
+			if(steptime < p_cyccb->lftime)
+			{
+				p_cyccb->lftime -= steptime;
+			}
+			else
+			{
+				p_cyccb->lftime = p_cyccb->cytime;		/* 残り時間リセット			*/
+
+				if(TCY_OFF != p_cyccb->cycact)
+				{
+					(p_cyccb->cychdr)();
+				}
+			}
+		}
+
+		depend_LeaveCriticalSection();
+	}
+}
+
+/**
+ * @brief	周期起動ハンドラ定義
+ *
+ * @param	cycno	周期起動ハンドラ指定番号
+ * @param	pk_dcyc	周期起動ハンドラ定義情報
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOMEM	メモリ不足(管理ブロック用の領域が確保できない)
+ * @retval	E_RSATR	予約属性(cycatrが不正あるいは利用できない)
+ * @retval	E_PAR	パラメータエラー(cycno, pk_dcyc, cychdr, cycact, cyctimが不正あるいは利用できない)
+ */
+ER def_cyc(HNO cycno, T_DCYC *pk_dcyc)
+{
+	ER result;
+
+	if(ISVALID_CYCNO(cycno))
+	{
+		T_CYCCB *p_cyccb;
+
+		p_cyccb = &(cyccbs[cycno]);
+
+		depend_EnterCriticalSection();
+
+		if(ISVALID_PTR(pk_dcyc))
+		{
+			*p_cyccb = cyccb_initializer;
+
+			p_cyccb->cycno = cycno;
+
+			p_cyccb->exinf = pk_dcyc->exinf;
+			p_cyccb->cycatr = pk_dcyc->cycatr;
+			p_cyccb->cychdr = pk_dcyc->cychdr;
+			p_cyccb->cycact = pk_dcyc->cycact;
+			p_cyccb->cyctim = pk_dcyc->cyctim;
+
+			p_cyccb->lftime		= pk_dcyc->cyctim.ltime;
+			p_cyccb->cytime		= pk_dcyc->cyctim.ltime;
+
+			result = E_OK;
+
+		}
+		else
+		{
+			*p_cyccb = cyccb_initializer;
+
+			result = E_OK;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	周期起動ハンドラ活性制御
+ *
+ * @param	cycno	周期起動ハンドラ指定番号
+ * @param	cyhact	周期起動ハンドラ活性状態
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOEXS	オブジェクトが存在していない(cycnoの周期起動ハンドラが定義されていない)
+ * @retval	E_PAR	パラメータエラー(cycnoが利用できない, cycactが不正)
+ */
+ER act_cyc(HNO cycno, UINT cyhact)
+{
+	ER result;
+
+	if(ISVALID_CYCNO(cycno))
+	{
+		if(ISVALID_CYCACT(cyhact))
+		{
+			T_CYCCB *p_cyccb;
+
+			p_cyccb = &(cyccbs[cycno]);
+
+			depend_EnterCriticalSection();
+
+			if(0 != p_cyccb->cycno)
+			{
+				p_cyccb->cycact = cyhact;
+
+				if(cyhact & TCY_INI)					/* 初期化指定あり?			*/
+				{
+					p_cyccb->lftime = p_cyccb->cytime;
+				}
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	周期起動ハンドラ状態参照
+ *
+ * @param	pk_rcyc	周期起動ハンドラの状態を返すパケットの先頭アドレス
+ * @param	cycno	周期起動ハンドラ指定番号
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOEXS	オブジェクトが存在していない(cycnoの周期起動ハンドラが定義されていない)
+ * @retval	E_PAR	パラメータエラー(cycnoが利用できない, リターンパラメータ用のパケットアドレスが使用できない値)
+ */
+ER ref_cyc(T_RCYC *pk_rcyc, HNO cycno)
+{
+	ER result;
+
+	if(ISVALID_CYCNO(cycno) && ISVALID_PTR(pk_rcyc))
+	{
+		T_CYCCB *p_cyccb;
+
+		p_cyccb = &(cyccbs[cycno]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_cyccb->cycno)
+		{
+			pk_rcyc->exinf = p_cyccb->exinf;
+			pk_rcyc->lfttim.ltime = p_cyccb->lftime;
+			pk_rcyc->cycact = p_cyccb->cycact;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/cyc.h
@@ -0,0 +1,18 @@
+#ifndef _CYC_H_
+#define _CYC_H_
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif	/* defined(__cplusplus) */
+
+#include <itron.h>
+
+ER cyc_initialize(void);
+void cyc_terminate(void);
+void cyc_timeevent(UINT steptime);
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */
+
+#endif	/* _CYC_H_ */

--- /dev/null
+++ b/src/depend/depend.h
@@ -0,0 +1,8 @@
+#ifndef _DEPEND_H_
+#define _DEPEND_H_
+
+#ifdef WIN32
+#include "depend/win32/depend_win32.h"
+#endif /* WIN32 */
+
+#endif /* _DEPEND_H_ */

--- /dev/null
+++ b/src/depend/win32/depend_win32.c
@@ -0,0 +1,523 @@
+#define _WIN32_WINNT 0x0500
+
+#include <windows.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include <mmsystem.h>
+#pragma comment(lib, "winmm.lib")
+
+#include "depend.h"
+#include <it3_debug.h>
+
+#define	ISVALID_TSKID(tskid)	((0 < (tskid)) && ((tskid) < DEPEND_TNUM_TSK))
+#define	ISVALID_TIMID(timid)	((0 < (timid)) && ((timid) < DEPEND_TNUM_TIM))
+
+/*
+===============================================================================
+	環境依存処理のための独自の型定義
+===============================================================================
+*/
+/* 環境依存処理 独自タスクのTCB */
+typedef struct S_DEPEND_TCB
+{
+	int tskid;
+
+	LPVOID p_fiber;							/* ファイバーアドレス		*/
+
+	void (*p_func)(void *);						/* 仮想タスクの開始アドレス	*/
+	void *p_param;								/* 仮想タスクに関連付けられたデータ
+													下記で取得できる
+													・仮想タスクの引数
+													・depend_get_param()
+												*/
+} T_DEPEND_TCB;
+
+typedef struct S_DEPEND_TIMCB
+{
+	int timid;
+
+	void (*p_func)(void *);
+	void *p_param;
+} T_DEPEND_TIMCB;
+
+static const T_DEPEND_TCB dep_tcb_initializer = {0};
+
+static const T_DEPEND_TIMCB dep_tim_initializer = {0};
+
+
+/*
+===============================================================================
+	環境依存処理のためのグローバル変数
+===============================================================================
+*/
+static DWORD tickcount = 0;
+
+/* 仮想タスクのための情報 */
+static T_DEPEND_TCB dep_tcbs[DEPEND_TNUM_TSK];
+
+static CRITICAL_SECTION cs;
+
+static HANDLE dep_timer_handle;
+static T_DEPEND_TIMCB dep_timcbs[DEPEND_TNUM_TIM];
+
+
+/*
+ 環境依存部分
+	仮想タスク		… ファイバー
+	仮想タスクID	… スレッドID
+
+ */
+
+static void ShowErrorMessage(void)
+{
+	LPVOID lpMsgBuf;
+
+	FormatMessage(	FORMAT_MESSAGE_ALLOCATE_BUFFER |
+					FORMAT_MESSAGE_FROM_SYSTEM |
+					FORMAT_MESSAGE_IGNORE_INSERTS,
+					NULL,
+					GetLastError(),
+					MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // 既定の言語
+					(LPTSTR) &lpMsgBuf,
+					0,
+					NULL
+	);
+
+	// 文字列を表示する。
+	IT3_LOG1("%s", lpMsgBuf);
+
+	// バッファを解放する。
+	LocalFree(lpMsgBuf);
+
+}
+
+/* 環境依存部分 タスク機能初期化 */
+static int depend_tsk_initialize(void)
+{
+	int result;
+	int cnt;
+	T_DEPEND_TCB *p_dep_tcb;
+	LPVOID p_fiber;
+
+	/* 仮想タスクのTCBを初期化 */
+	for(cnt = 0;cnt < DEPEND_TNUM_TSK;cnt++)
+	{
+		dep_tcbs[cnt] = dep_tcb_initializer;
+	}
+
+	/* ============================
+	 * スレッドをファイバーに変換
+	 * ============================ */
+	/* カーネルの環境依存TCBを取得 */
+	p_dep_tcb = &(dep_tcbs[0]);
+
+	/* この処理を動かしたスレッドをuITRONのカーネル用ファイバとする */
+	p_fiber = ConvertThreadToFiber(p_dep_tcb);
+	if(p_fiber)
+	{
+		p_dep_tcb->p_fiber = p_fiber;
+
+		result = 0;
+	}
+	else
+	{
+		result = (-1);
+	}
+
+	return result;
+}
+
+static void depend_tsk_terminate(void)
+{
+	int cnt;
+	T_DEPEND_TCB *p_dep_tcb;
+	BOOL ret;
+
+	for(cnt = 1;cnt < DEPEND_TNUM_TSK;cnt++)
+	{
+		p_dep_tcb = &(dep_tcbs[cnt]);
+
+		if(0 != p_dep_tcb)
+		{
+			DeleteFiber(p_dep_tcb->p_fiber);
+			*p_dep_tcb = dep_tcb_initializer;
+		}
+	}
+
+	/* カーネル用ファイバをスレッドに戻す */
+	ret = ConvertFiberToThread();
+	if(! ret)
+	{
+		ShowErrorMessage();
+	}
+	dep_tcbs[0] = dep_tcb_initializer;
+}
+
+static int depend_tim_initialize(void)
+{
+	int result;
+	HANDLE timer_handle;
+
+	timer_handle = CreateTimerQueue();
+	if(NULL != timer_handle)
+	{
+		dep_timer_handle = timer_handle;
+		result = 0;
+	}
+	else
+	{
+		ShowErrorMessage();
+		result = (-1);
+	}
+
+	return result;
+}
+
+static void depend_tim_terminate(void)
+{
+	if(NULL != dep_timer_handle)
+	{
+		DeleteTimerQueueEx(dep_timer_handle, NULL);
+		dep_timer_handle = NULL;
+	}
+}
+
+/* 環境依存部分の初期化 */
+int depend_initialize(void)
+{
+	int result;
+	int ret;
+
+	ret = depend_CreateCriticalSection();
+	if(0 == ret)
+	{
+		/* 仮想タスク機能の初期化 */
+		ret = depend_tsk_initialize();
+		if(0 == ret)
+		{
+			ret = depend_tim_initialize();
+			if(0 == ret)
+			{
+				/* 起動時刻を取得 */
+				tickcount = GetTickCount();
+
+				result = 0;
+			}
+			else
+			{
+				depend_tsk_terminate();
+				depend_DestoryCriticalSection();
+				result = (-3);
+			}
+		}
+		else
+		{
+			depend_DestoryCriticalSection();
+			result = (-2);
+		}
+	}
+	else
+	{
+		result = (-1);
+	}
+
+	return result;
+}
+
+/* 環境依存部分の終了 */
+void depend_terminate(void)
+{
+	depend_tim_terminate();
+	depend_tsk_terminate();
+	depend_DestoryCriticalSection();
+}
+
+/* 呼出している制御に関連付けられたデータを返す */
+void * depend_GetParam(void)
+{
+	void *p_param = NULL;
+
+	__try
+	{
+		T_DEPEND_TCB *p_dep_tcb;
+
+		/*
+		 * この関数を動かしているファイバーに関連付けられたデータを取得する
+		 * この値は、depend_cre_tskのT_DEP_CRE_TSKp_dataCreateFiber,ConvertThreadToFiberで
+		 * 与えられた値である
+		 */
+		p_dep_tcb = (T_DEPEND_TCB *)GetFiberData();
+		if(p_dep_tcb)
+		{
+			p_param = p_dep_tcb->p_param;
+		}
+	}
+	__finally
+	{
+		/* この関数を動かしているのは、ファイバーじゃない */
+	}
+
+	return p_param;
+}
+
+VOID CALLBACK FiberProc(PVOID lpParameter)   // ファイバデータ
+{
+	T_DEPEND_TCB *p_dep_tcb = lpParameter;
+
+	(p_dep_tcb->p_func)(p_dep_tcb->p_param);
+}
+
+/* 仮想タスクを生成する */
+int depend_CreateTask(int tskid, const T_DEPEND_CTSK *p_dep_ctsk)
+{
+	int result;
+	T_DEPEND_TCB *p_dep_tcb;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		p_dep_tcb = &(dep_tcbs[tskid]);
+
+		if(0 != p_dep_tcb->tskid)
+		{
+			p_dep_tcb->tskid = tskid;
+			p_dep_tcb->p_func	= p_dep_ctsk->p_func;
+			p_dep_tcb->p_param	= p_dep_ctsk->p_param;
+
+			p_dep_tcb->p_fiber = CreateFiber(p_dep_ctsk->stksz, FiberProc, p_dep_tcb);
+			if(NULL != p_dep_tcb->p_fiber)
+			{
+				result = 0;
+			}
+			else
+			{
+				*p_dep_tcb = dep_tcb_initializer;
+				result = (-3);
+			}
+		}
+		else
+		{
+			result = (-2);
+		}
+	}
+	else
+	{
+		result = (-1);
+	}
+
+	return result;
+}
+
+int depend_DestoryTask(int tskid)
+{
+	int result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_DEPEND_TCB *p_dep_tcb;
+
+		p_dep_tcb = &(dep_tcbs[tskid]);
+
+		if(0 != p_dep_tcb->tskid)
+		{
+			DeleteFiber(p_dep_tcb->p_fiber);
+
+			*p_dep_tcb = dep_tcb_initializer;
+
+			/* カーネルに制御を移す */
+	//		depend_wakeup_tsk(0);
+
+			result = 0;
+		}
+		else
+		{
+			result = (-2);
+		}
+	}
+	else
+	{
+		result = (-1);
+	}
+
+	return result;
+}
+
+int depend_SetTimer(int timid, T_DEPEND_CTIM *p_ctim)
+{
+	int result;
+
+	if(ISVALID_TIMID(timid))
+	{
+		T_DEPEND_TIMCB *p_timcb;
+
+		p_timcb = &(dep_timcbs[timid]);
+		if(0 != p_timcb->timid)
+		{
+			HANDLE tim_handle;
+			BOOL ret;
+
+			p_timcb->timid = timid;
+#if 0 // TODO
+			ret = CreateTimerQueueTimer(&tim_handle, dep_timer_handle, )
+			if()
+#endif
+
+			result = 0;
+		}
+		else
+		{
+			result = (-2);
+		}
+	}
+	else
+	{
+		result = (-1);
+	}
+
+	return result;
+}
+
+int depend_KillTimer(int timid)
+{
+	int result;
+
+	// TODO
+	result = 0;
+
+	return result;
+}
+
+/* イベントの生成 */
+void* depend_cre_evt(const char *p_name)
+{
+	void * hEventToKernel;
+	hEventToKernel = CreateEvent(NULL, FALSE, FALSE, p_name);
+
+	return hEventToKernel;
+}
+
+/* イベントの破棄 */
+int depend_des_evt(void *p_handle_evt)
+{
+	CloseHandle((HANDLE)p_handle_evt);
+
+	return 0;
+}
+
+/* イベントを待つ */
+int depend_wai_evt(void *p_handle_evt, int time)
+{
+	DWORD d;
+
+	if(-1 == time)								/* 無期限指定? */
+	{
+		time = INFINITE;
+	}
+
+	d = WaitForSingleObject((HANDLE)p_handle_evt, time);
+
+	return 0;
+}
+
+/* イベントを設定 */
+int depend_set_evt(void *p_handle_evt)
+{
+	SetEvent((HANDLE)p_handle_evt);
+
+	return 0;
+}
+
+/* 指定時間だけ処理を止める（ミリ秒） */
+void depend_sleep(int time)
+{
+	Sleep(time);
+}
+
+/* 現在時刻取得 */
+int depend_get_time(void)
+{
+	int time;
+	DWORD new_tickcount;
+
+	new_tickcount = GetTickCount();
+
+	if(tickcount <= new_tickcount)
+	{
+		time = new_tickcount - tickcount;
+	}
+	else
+	{
+		time = (ULONG_MAX - tickcount) + new_tickcount;
+	}
+
+	return time;
+}
+
+/* 指定された仮想タスクに制御を切り替える */
+int depend_SwitchTask(int tskid)
+{
+	IT3_ASSERT(ISVALID_TSKID(tskid));
+
+	SwitchToFiber(dep_tcbs[tskid].p_fiber);
+
+	return 0;
+}
+
+/* メッセージ表示 */
+void depend_message_show(const char *p_fmt, ...)
+{
+	char buff[256];
+	va_list arg;
+
+	va_start(arg, p_fmt);				/* Initialize variable arguments.	*/
+
+	vsprintf(buff, p_fmt, arg);
+
+	va_end(arg);						/* Reset variable arguments.		*/
+
+	MessageBox(NULL, buff, "ASSERT", MB_OK | MB_ICONINFORMATION);
+}
+
+void * depend_malloc(int size)
+{
+	return malloc(size);
+}
+
+void depend_free(void *p_mem)
+{
+	free(p_mem);
+}
+
+int depend_CreateCriticalSection(void)
+{
+	int result;
+
+	__try
+	{
+		InitializeCriticalSection(&cs);
+		result = 0;
+	}
+	__except(STATUS_NO_MEMORY)
+	{
+		IT3_LOG("CriticalSection not enough memory.");
+		result = (-1);
+	}
+
+	return result;
+}
+
+void depend_DestoryCriticalSection(void)
+{
+	DeleteCriticalSection(&cs);
+}
+
+void depend_EnterCriticalSection(void)
+{
+	EnterCriticalSection(&cs);
+}
+
+void depend_LeaveCriticalSection(void)
+{
+	LeaveCriticalSection(&cs);
+}

--- /dev/null
+++ b/src/depend/win32/depend_win32.h
@@ -0,0 +1,83 @@
+#ifndef _DEPEND_WIN32_H_
+#define _DEPEND_WIN32_H_
+
+/* 環境依存部分でサポートできるタスク数 */
+#define	DEPEND_TNUM_TSK			(256)
+
+/* 環境依存部分でサポートできるタイマ数 */
+#define	DEPEND_TNUM_TIM			(256)
+
+typedef struct S_DEPEND_CTSK
+{
+	unsigned long stksz;					/* スタックサイズ(byte)		*/
+	void (*p_func)(void *);				/* 仮想タスクの開始アドレス	*/
+	void *p_param;							/* 仮想タスクに関連付けるデータ
+												以下のタイミングで取得できるようになる
+												・仮想タスクの引数
+												・depend_get_paramの戻り値
+											*/
+} T_DEPEND_CTSK;
+
+typedef struct S_DEPEND_CTIM
+{
+	void (*p_func)(void *);				/* タイマのコールバック関数アドレス	*/
+	void *p_param;							/* コールバック関数に渡す引数			*/
+} T_DEPEND_CTIM;
+
+/* 環境依存部分の初期化 */
+int depend_initialize(void);
+
+/* 環境依存部分の終了 */
+void depend_terminate(void);
+
+/* 仮想タスクの作成 */
+int depend_CreateTask(int tskid, const T_DEPEND_CTSK *p_dep_ctsk);
+
+/* 仮想タスクの破棄 */
+int depend_DestoryTask(int tsk);
+
+/* 仮想タスク起床 */
+int depend_SwitchTask(int tskid);
+
+/* 仮想タスクに関連付けられたデータを取得 */
+void * depend_GetParam(void);
+
+void * depend_malloc(int size);
+void depend_free(void *p_mem);
+
+int depend_CreateCriticalSection(void);
+void depend_DestoryCriticalSection(void);
+void depend_EnterCriticalSection(void);
+void depend_LeaveCriticalSection(void);
+
+
+
+
+/* イベントの生成 */
+void * depend_cre_evt(const char *p_name);
+
+/* イベントの破棄 */
+int depend_des_evt(void *p_handle_evt);
+
+/* イベントを待つ */
+int depend_wai_evt(void *p_handle_evt, int time);
+
+/* イベントを設定 */
+int depend_set_evt(void *p_handle_evt);
+
+/* 実行停止 */
+void depend_sleep(int time);
+
+/* 現在時刻取得 */
+int depend_get_time(void);
+
+
+
+
+
+
+/* メッセージ表示 */
+void depend_message_show(const char *p_fmt, ...);
+
+
+#endif /* _DEPEND_WIN32_H_ */

--- /dev/null
+++ b/src/flg.c
@@ -0,0 +1,888 @@
+#include "flg.h"
+#include "it3_debug.h"
+#include "it3_common.h"
+#include "it3_config.h"
+
+#include "que_ctl.h"
+#include "tsk.h"
+#include "kernel.h"
+
+#define	ISVALID_FLGID(flgid)	((0 < flgid) && (flgid < TNUM_FLG))
+#define	ISVALID_FLGATR(flgatr)	(TRUE)		/* 属性値はチェックしない */
+#define	ISVALID_WFMODE(wfmode)	(0 == ((wfmode) & ~(TWF_ORW | TWF_CLR)))
+#define	ISVALID_TMOUT(tmout)	((0 < (tmout)) || (TMO_FEVR == (tmout)) || (TMO_POL == (tmout)))
+
+typedef struct S_FLGCB
+{
+	ID			flgid;							/**< イベントフラグID			*/
+	VP			exinf;							/**< 拡張情報					*/
+	ATR			flgatr;							/**< 属性情報					*/
+	UINT		flgptn;							/**< フラグパターン				*/
+
+	T_LST		wtsklst;						/**< 待ちタスクリスト				*/
+
+//	T_TCB		*head;							/**< 先頭TCBへのポインタ			*/
+//	VH			wtskmode;						/**< 待ち順序					*/
+//	ID			wtskcnt;						/**< 待ちタスク数				*/
+//	VB			dmy[4];							/**< ダミー						*/
+
+} T_FLGCB;
+
+static const T_FLGCB flgcb_initializer = {0};
+
+static T_FLGCB flgcb[TNUM_FLG];
+
+/* イベントフラグ待ちキューにタスクを追加 */
+static void add_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_flgcb);
+	IT3_ASSERT(p_tcb);
+
+	if(TA_TPRI & p_flgcb->flgatr)
+	{
+		T_LST *p_insert_pos;
+
+		p_insert_pos = p_flgcb->wtsklst.p_next;
+
+		while(&(p_flgcb->wtsklst) != p_insert_pos)
+		{
+			if(p_tcb->tskpri < ((T_TCB *)p_insert_pos)->tskpri)
+			{
+				break;
+			}
+
+			p_insert_pos = p_insert_pos->p_next;
+		}
+
+		lst_insert(p_insert_pos, (T_LST *)p_tcb);
+	}
+	else
+	{
+		lst_insert(&(p_flgcb->wtsklst), (T_LST *)p_tcb);
+	}
+
+#if 0 // T_LSTへ移行するので使うのやめる
+	T_FLGCB *p_flgq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_flgq = &flgcb[addtcb->wid];
+
+	toptcb = p_flgq->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		if( p_flgq->wtskmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			addtcb->prev = endtcb;
+			addtcb->next = toptcb;
+			toptcb->prev = addtcb;
+			endtcb->next = addtcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( addtcb->pri < nextcb->pri )
+				{
+					pretcb = nextcb->prev;
+
+					addtcb->prev = pretcb;
+					addtcb->next = nextcb;
+					nextcb->prev = addtcb;
+					pretcb->next = addtcb;
+
+					if( nextcb == toptcb )
+					{
+						p_flgq->head = addtcb;
+					}
+
+					break;
+				}
+
+				nextcb = nextcb->next;
+			} while((nextcb != toptcb) && (p_flgq->head != NULL));
+
+			if( nextcb == toptcb )
+			{
+				addtcb->prev = endtcb;
+				addtcb->next = toptcb;
+				toptcb->prev = addtcb;
+				endtcb->next = addtcb;
+			}
+		}
+
+		(p_flgq->wtskcnt)++;				/* 待ちタスク数を加算 */
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_flgq->head   = addtcb;
+		addtcb->next = addtcb;
+		addtcb->prev = addtcb;
+
+		p_flgq->wtskcnt = 1;					/* 待ちタスク数は１ */
+	}
+
+	return;
+#endif
+}
+
+/* イベントフラグ待ちキューからタスクを削除 */
+void del_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb)
+{
+	lst_delete((T_LST *)p_tcb);
+
+#if 0 // T_LSTへ移行するので使うのやめる
+	T_FLGCB	*p_flgq;
+	T_TCB	*pretcb, *nextcb;
+
+	p_flgq = &flgcb[deltcb->wid];
+
+	if( (pretcb = deltcb->prev) != deltcb )
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+		if( p_flgq->head == deltcb )
+		{
+			p_flgq->head = nextcb;
+		}
+
+		( p_flgq->wtskcnt )--;		/* 待ちタスク数を減算 */
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_flgq->head = NULL;
+
+		p_flgq->wtskcnt = 0;			/* 待ちタスク数は０ */
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+#endif
+}
+
+/**
+ * @brief	同期・通信機能（イベントフラグ）初期化処理
+ */
+ER flg_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_FLG;cnt++)
+	{
+		flgcb[cnt] = flgcb_initializer;
+	}
+
+	return E_OK;
+}
+
+/**
+ * @brief	同期・通信機能（イベントフラグ）終了処理
+ */
+void flg_terminate(void)
+{
+}
+
+/*----------------- 同期、通信機能（イベントフラグ）---------------------*/
+/* イベントフラグ生成 */
+ER cre_flg(ID flgid, T_CFLG *pk_cflg)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		if(ISVALID_PTR(pk_cflg))
+		{
+			T_FLGCB *p_flgcb;
+
+			p_flgcb = &(flgcb[flgid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 == p_flgcb->flgid)
+			{
+				*p_flgcb = flgcb_initializer;
+
+				p_flgcb->flgid = flgid;
+
+				p_flgcb->exinf = pk_cflg->exinf;
+				p_flgcb->flgatr = pk_cflg->flgatr;
+				p_flgcb->flgptn = pk_cflg->iflgptn;			/* イベントフラグ初期値	*/
+
+				lst_init(&(p_flgcb->wtsklst));
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* イベントフラグ削除 */
+ER del_flg(ID flgid)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		T_FLGCB *p_flgcb;
+
+		p_flgcb = &(flgcb[flgid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_flgcb->flgid)
+		{
+			T_TCB *p_tcb;
+
+			/*----- 条件成立を待っているタスクの待ち解除 -----*/
+			while(! lst_empty(&(p_flgcb->wtsklst)))
+			{
+				p_tcb = (T_TCB *)(p_flgcb->wtsklst.p_next);
+
+				del_flgq(p_flgcb, p_tcb);						/* FLGQ から TCB を外す */
+
+				if(WTIM & p_tcb->tskwait)					/* タイムアウトあり */
+				{
+					T_TCBTMO *p_tcbtmo = &(tcbtmoq[p_tcb->tskid]);
+					del_timq(p_tcbtmo);	/* TIMQ から TCB を外す */
+					p_tcbtmo->sts = 0;
+				}
+
+				/* エラーコードを待ちオブジェクトの削除に */
+				*(p_tcb->p_wercd) = E_DLT;
+
+				p_tcb->tskstat &= ~(TTS_WAI);
+				p_tcb->tskwait &= ~(WTIM | TTW_FLG);
+				p_tcb->wid = 0;
+				if(0 == (TTS_SUS & tcb->tskstat))
+				{
+					p_tcb->tskstat = TTS_RDY;				/* タスク状態を READY に */
+					p_tcb->tskwait = 0;
+					p_tcb->wid = 0;
+					add_rdq(p_tcb);						/* RDQ に TCB をつなげる */
+				}
+			}
+
+			*p_flgcb = flgcb_initializer;
+
+			/* ディスパッチされるまで待つ */
+			tsk_wait_dispatch();
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* イベントフラグのセット */
+ER set_flg(ID flgid, UINT setptn)
+{
+	ER result;
+
+	result = iset_flg(flgid, setptn);
+	if(E_OK == result)
+	{
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return result;
+}
+
+/* イベントフラグのセット(タスク独立部専用) */
+ER iset_flg(ID flgid, UINT setptn)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		T_FLGCB *p_flgcb;
+		T_TCB *p_tcb, *p_next_tcb;
+		UINT ptn;
+
+		p_flgcb = &(flgcb[flgid]);
+
+		depend_EnterCriticalSection();
+
+		p_flgcb->flgptn |= setptn;
+
+		p_tcb = (T_TCB *)(p_flgcb->wtsklst.p_next);
+
+		while(&(p_flgcb->wtsklst) != (T_LST *)p_tcb)
+		{
+			p_next_tcb = (T_TCB *)(((T_LST *)p_tcb)->p_next);
+
+			ptn = p_flgcb->flgptn & p_tcb->wait.wflg.waiptn;
+
+			if(	((0 != (p_tcb->wait.wflg.wfmode & TWF_ANDW)) && (p_tcb->wait.wflg.waiptn == ptn)) ||
+				((0 != (p_tcb->wait.wflg.wfmode & TWF_ORW))  && (0 != ptn))	)
+			{
+				/* 条件成立 */
+
+				*(UW *)p_tcb->arg = p_flgcb->flgptn;	/* 待ち解除時フラグパターン */
+
+				if(0 != (p_tcb->wait.wflg.wfmode & TWF_CLR))	/* クリア指定あり */
+				{
+					p_flgcb->flgptn &= ~(p_tcb->wait.wflg.waiptn);
+				}
+
+				del_flgq(p_flgcb, p_tcb);		/* FLGQ から TCB を外す       */
+				p_tcb->wait.wflg.wfmode = 0;		/* TCB の待ちパターンをクリア */
+
+				if(WTIM & p_tcb->tskstat)		/* タイムアウトあり */
+				{
+					T_TCBTMO *p_tcbtmo = &(tcbtmoq[p_tcb->tskid]);
+					del_timq(p_tcbtmo);				/* TIMQ から TCB を外す */
+					p_tcbtmo->sts = 0;
+				}
+
+				if(TTS_SUS == p_tcb->tskstat)
+				{
+					/* 二重待ち状態 */
+					p_tcb->tskstat = TTS_SUS;			/* タスク状態を SUSPEND に */
+				}
+				else
+				{
+					/* メッセージ待ち状態 */
+					add_rdq(p_tcb);					/* RDQ に TCB をつなげる */
+					p_tcb->tskstat = TTS_RDY;			/* タスク状態を READY に */
+				}
+			}
+
+			p_tcb = p_next_tcb;
+		}
+
+		depend_LeaveCriticalSection();
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+#if 0
+	T_FLGCB *p_flgq;
+	T_TCB *p_tcb, *p_next_tcb;
+	UH wtskcnt;
+	INT i;
+	UW ptn;
+
+	/* パラメータチェック */
+	if(! ISVALID_FLGID(flgid))
+	{
+		return E_ID;
+	}
+
+	p_flgq = &(flgcb[flgid]);
+
+	/* イベントフラグの値を設定 */
+	p_flgq->flgptn |= setptn;
+
+	p_tcb = p_flgq->head;
+	wtskcnt = p_flgq->wtskcnt;	/* イベントフラグ待ちタスクの数 */
+
+	for(i = 0;i < wtskcnt;i++)
+	{
+		p_next_tcb = p_tcb->next;
+
+		ptn = p_flgq->flgptn & p_tcb->waiptn;
+
+		if(	((0 != (p_tcb->wfmode & TWF_ANDW)) && (p_tcb->waiptn == ptn)) ||
+			((0 != (p_tcb->wfmode & TWF_ORW))  && (0 != ptn))	)
+		{
+			/* 条件成立 */
+
+			*(UW *)p_tcb->arg = p_flgq->flgptn;	/* 待ち解除時フラグパターン */
+
+			if(0 != (p_tcb->wfmode & TWF_CLR))	/* クリア指定あり */
+			{
+				p_flgq->flgptn &= ~(p_tcb->waiptn);
+			}
+
+			del_flgq(p_flgq, p_tcb);		/* FLGQ から TCB を外す       */
+			p_tcb->wfmode = 0;		/* TCB の待ちパターンをクリア */
+
+			if(WTIM & p_tcb->tskstat)		/* タイムアウトあり */
+			{
+				T_TCBTMO *p_tcbtmo = &(tcbtmoq[p_tcb->tskid]);
+				del_timq(p_tcbtmo);				/* TIMQ から TCB を外す */
+				p_tcbtmo->sts = 0;
+			}
+
+			if(TTS_SUS == p_tcb->tskstat)
+			{
+				/* 二重待ち状態 */
+				p_tcb->tskstat = TTS_SUS;			/* タスク状態を SUSPEND に */
+			}
+			else
+			{
+				/* メッセージ待ち状態 */
+				add_rdq(p_tcb);					/* RDQ に TCB をつなげる */
+				p_tcb->tskstat = TTS_RDY;			/* タスク状態を READY に */
+			}
+		}
+
+		p_tcb = p_next_tcb;
+	}
+
+	return E_OK;
+#endif
+}
+
+/* イベントフラグのクリア */
+ER clr_flg(ID flgid, UINT clrptn)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		T_FLGCB *p_flgcb;
+
+		p_flgcb = &(flgcb[flgid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_flgcb->flgid)
+		{
+			p_flgcb->flgptn &= clrptn;
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* イベントフラグ待ち */
+ER wai_flg(UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode)
+{
+	return twai_flg(p_flgptn, flgid, waiptn, wfmode, TMO_FEVR);
+
+#if 0 // TODO もうやめる
+	T_FLGCB *p_flgq;
+	T_TCB *p_tcb;
+	ER ercd;
+	UINT ptn;
+
+	/* パラメータチェック */
+	if(! ISVALID_FLGID(flgid))
+	{
+		return E_ID;
+	}
+
+	if(0 == waiptn)
+	{
+		/* waiptn が不正 */
+		return  E_PAR;
+	}
+
+	if(0 != (wfmode & ~(TWF_ANDW | TWF_ORW | TWF_CLR)))
+	{
+		/* wfmode が不正 */
+		return E_PAR;
+	}
+
+	p_flgq = &(flgcb[flgid]);
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	/* タスクの待ち条件と一致するか? */
+	ptn = p_flgq->flgptn & waiptn;	/* フラグパターン判定 */
+
+	if(	((0 != (wfmode & TWF_ANDW)) && (ptn == waiptn)) ||
+		((0 != (wfmode & TWF_ORW))  && (ptn != 0))	)
+	{
+		*p_flgptn = p_flgq->flgptn;	/* 待ち解除時フラグパターン */
+
+		if(0 != (TWF_CLR & wfmode))	/* クリア指定あり? */
+		{
+			/* ビットパターンをクリア */
+			p_flgq->flgptn &= ~(waiptn);
+		}
+	}
+	else
+	{
+		/* TCBをRDQから外す */
+		del_rdq(p_tcb);
+
+		/* タスク状態をWAITにする */
+		p_tcb->tskstat = TTS_WAI;
+		p_tcb->tskwait = TTW_FLG;
+		p_tcb->wid = flgid;
+
+		/* waiptn,wfmodeをTCBに設定 */
+		p_tcb->waiptn = waiptn;
+		p_tcb->wfmode = wfmode;
+
+		/* 引数を保存 */
+		p_tcb->arg = (VP)p_flgptn;
+
+		if(TA_TFIFO == p_flgq->wtskmode)		/* 待ち行列はFIFO? */
+		{
+			/* TCBをFLGQにつなぐ */
+			add_flgq(p_flgq, p_tcb);
+		}
+		else
+		{
+			/* 優先順位の高い方から挿入位置を検索 */
+			/* FLGQの検索した位置にTCBをつなぐ */
+			add_flgq(p_flgq, p_tcb);
+		}
+	}
+
+	/* ディスパッチされるまで待つ */
+	tsk_wait_dispatch();
+
+	return E_OK;
+#endif
+}
+
+/* イベントフラグ待ち(ポーリング) */
+ER pol_flg(UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode)
+{
+	return twai_flg(p_flgptn, flgid, waiptn, wfmode, TMO_POL);
+
+#if 0 // TODO もうやめ
+	ER ercd;
+	T_FLGCB *p_flgq;
+	T_TCB *p_tcb;
+	UINT ptn;
+
+	/* パラメータチェック */
+	if(! ISVALID_FLGID(flgid))
+	{
+		return E_ID;
+	}
+
+	if(0 != (wfmode & ~(TWF_ANDW | TWF_ORW | TWF_CLR)))
+	{
+		/* wfmode が不正 */
+		return E_PAR;
+	}
+
+	if(0 == waiptn)
+	{
+		/* waiptn が不正 */
+		return E_PAR;
+	}
+
+	p_flgq = &(flgcb[flgid]);
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	/*-------------------- イベントフラグを得る ---------------------*/
+	ptn = p_flgq->flgptn & waiptn;
+
+	if(	((0 != (wfmode & TWF_ANDW)) && (ptn == waiptn)) ||
+		((0 != (wfmode & TWF_ORW))  && (ptn != 0))	)
+	{
+		/* 条件成立 */
+
+		*p_flgptn = p_flgq->flgptn;	/* 待ち解除時フラグパターン */
+
+		if(0 != (wfmode & TWF_CLR))				/* クリア指定あり? */
+		{
+			p_flgq->flgptn &= ~(waiptn);
+		}
+	}
+	else
+	{
+		return E_TMOUT;
+	}
+
+	return E_OK;
+#endif
+}
+
+/* イベントフラグ待ち(タイムアウト有)) */
+ER twai_flg(UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		if((0 != waiptn) && ISVALID_WFMODE(wfmode) && ISVALID_TMOUT(tmout))
+		{
+			T_FLGCB *p_flgcb;
+			ER ret;
+			T_TCB *p_tcb;
+
+			p_flgcb = &(flgcb[flgid]);
+
+			ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+			if(E_OK == ret)
+			{
+				depend_EnterCriticalSection();
+
+				if(	((TWF_ORW & wfmode) && ((waiptn & p_flgcb->flgptn) != 0)) ||
+					((waiptn & p_flgcb->flgptn) == waiptn))
+				{
+					if(p_flgptn)
+					{
+						*p_flgptn = p_flgcb->flgptn;
+					}
+
+					if(0 != (TWF_CLR & wfmode))				/* クリア指定あり? */
+					{
+						p_flgcb->flgptn = 0;
+					}
+
+					result = E_OK;
+				}
+				else
+				{
+					if(TMO_POL == tmout)
+					{
+						result = E_TMOUT;
+					}
+					else if(TMO_FEVR == tmout)
+					{
+						del_rdq(p_tcb);							/* RDQ から TCB を外す */
+
+						p_tcb->tskstat = TTS_WAI;
+						p_tcb->tskwait = TTW_FLG;
+						p_tcb->wid = flgid;
+
+						p_tcb->arg = (VB *)p_flgptn;			/* 戻り値用のアドレスを保存 */
+						p_tcb->wait.wflg.waiptn = waiptn;					/* 待ちパターンを設定 */
+						p_tcb->wait.wflg.wfmode = wfmode;					/* 待ちモードを設定 */
+
+						add_flgq(p_flgcb, p_tcb);						/* FLGQ に TCB をつなげる */
+
+						/* ディスパッチされるまで待つ */
+						tsk_wait_dispatch();
+
+						result = E_OK;
+					}
+					else
+					{
+						T_TCBTMO *p_tcbtmo = &(tcbtmoq[p_tcb->tskid]);
+
+						del_rdq(p_tcb);							/* RDQ から TCB を外す */
+						p_tcb->tskstat = TTS_WAI;
+						p_tcb->tskwait = WTIM | TTW_FLG;
+						p_tcb->wid = flgid;	/* フラグ ID を設定 */
+
+						p_tcb->arg = (VB *)p_flgptn;	/* 戻り値用のアドレスを保存 */
+						p_tcb->wait.wflg.waiptn = waiptn;		/* 待ちパターンを設定 */
+						p_tcb->wait.wflg.wfmode = wfmode;		/* 待ちモードを設定 */
+
+						p_tcbtmo->sts = p_tcb->tskstat;
+						p_tcbtmo->tmout = timq.time + tmout; /* タイムアウト時刻を設定 */
+
+						add_flgq(p_flgcb, p_tcb);		/* FLGQ に TCB をつなげる */
+						add_timq(p_tcb);	/* 時間待ち行列につなぐ */
+
+						/* ディスパッチされるまで待つ */
+						tsk_wait_dispatch();
+
+						result = E_OK;
+					}
+				}
+
+				depend_LeaveCriticalSection();
+			}
+			else
+			{
+				result = ret;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+
+#if 0 // TODO 変える
+	ER ercd;
+//	UINT wfmode = pararr[0];
+//	TMO tmout  = pararr[1];
+
+	T_FLGCB *p_flgq;
+	T_TCB *p_tcb;
+
+//	if (DSPENA == OFF) return E_CTX;	/* コンテキストエラー */
+
+	/*----- パラメータエラー判定 -----*/
+	if(! ISVALID_FLGID(flgid))
+	{
+		return E_ID;							/* 不正 ID 番号 */
+	}
+
+	if(0 == waiptn)
+	{
+		return E_PAR;	/* パラメータエラー */
+	}
+
+	p_flgq = &(flgcb[flgid]);
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	/*----- イベントフラグ待ち -----*/
+	if(	((TWF_ORW & wfmode) && ((waiptn & p_flgq->flgptn) != 0)) ||
+		((waiptn & p_flgq->flgptn) == waiptn))
+	{
+		/* 条件成立 */
+		*p_flgptn = p_flgq->flgptn;	/* 待ち解除時フラグパターン */
+
+		if(0 != (TWF_CLR & wfmode))				/* クリア指定あり? */
+		{
+			p_flgq->flgptn = 0;
+		}
+
+		return E_OK;
+	}
+
+	if(TMO_POL == tmout)
+	{
+		return E_TMOUT;
+	}
+	else if(TMO_FEVR == tmout)
+	{
+		del_rdq(p_tcb);							/* RDQ から TCB を外す */
+		p_tcb->tskstat = TTS_WAI;
+		p_tcb->tskwait = TTW_FLG;
+		p_tcb->wid = flgid;						/* フラグ ID を設定 */
+
+		p_tcb->arg = (VB *)p_flgptn;			/* 戻り値用のアドレスを保存 */
+		p_tcb->waiptn = waiptn;					/* 待ちパターンを設定 */
+		p_tcb->wfmode = wfmode;					/* 待ちモードを設定 */
+
+		add_flgq(p_flgq, p_tcb);						/* FLGQ に TCB をつなげる */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+		return E_OK;
+	}
+	else
+	{
+		T_TCBTMO *p_tcbtmo = &(tcbtmoq[p_tcb->tskid]);
+
+		del_rdq(p_tcb);							/* RDQ から TCB を外す */
+		p_tcb->tskstat = TTS_WAI;
+		p_tcb->tskwait = WTIM | TTW_FLG;
+		p_tcb->wid = flgid;	/* フラグ ID を設定 */
+
+		p_tcb->arg = (VB *)p_flgptn;	/* 戻り値用のアドレスを保存 */
+		p_tcb->waiptn = waiptn;		/* 待ちパターンを設定 */
+		p_tcb->wfmode = wfmode;		/* 待ちモードを設定 */
+
+		p_tcbtmo->sts = p_tcb->sts;
+		p_tcbtmo->tmout = timq.time + tmout; /* タイムアウト時刻を設定 */
+
+		add_flgq(p_flgq, p_tcb);		/* FLGQ に TCB をつなげる */
+		add_timq(p_tcb);	/* 時間待ち行列につなぐ */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+		return E_OK;
+	}
+#endif
+}
+
+/* イベントフラグ状態参照 */
+ER ref_flg(T_RFLG *pk_rflg, ID flgid)
+{
+	ER result;
+
+	if(ISVALID_FLGID(flgid))
+	{
+		if(ISVALID_PTR(pk_rflg))
+		{
+			T_FLGCB *p_flgcb;
+
+			p_flgcb = &(flgcb[flgid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 != p_flgcb->flgid)
+			{
+				pk_rflg->exinf = p_flgcb->exinf;
+				pk_rflg->wtsk = (lst_empty(&(p_flgcb->wtsklst))) ? FALSE : ((T_TCB *)(p_flgcb->wtsklst.p_next))->tskid;
+				pk_rflg->flgptn = p_flgcb->flgptn;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/flg.h
@@ -0,0 +1,9 @@
+#ifndef _FLG_H_
+#define _FLG_H_
+
+#include <itron.h>
+
+ER flg_initialize(void);
+void flg_terminate(void);
+
+#endif /* _FLG_H_ */

--- /dev/null
+++ b/src/int.c
@@ -0,0 +1,186 @@
+#include "int.h"
+#include "it3_common.h"
+#include "it3_config.h"
+#include <depend.h>
+
+#define	ISVALID_INTNO(intno)	((0 < (intno)) && ((intno) < TNUM_INT))
+#define	ISVALID_INTATR(intatr)	(TRUE)	/* 属性をチェックしない */
+
+/* 割込みハンドラ定義情報 */
+typedef struct S_INTCB
+{
+	UINT				intno;
+
+	ATR					intatr;		/* 割込みハンドラ属性					*/
+	FP					inthdr;		/* 割込みハンドラアドレス				*/
+
+	/* インプリメント依存の情報 */
+	B					intmsk;		/* 割込みマスク							*/
+	B					intpri;		/* 割込みレベル							*/
+
+} T_INTCB;
+
+static const T_INTCB intcb_initializer = {0};
+
+static T_INTCB intcbs[TNUM_INT];
+
+ER int_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_INT;cnt++)
+	{
+		intcbs[cnt] = intcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void int_terminate(void)
+{
+}
+
+ER int_event(void)
+{
+	INT cnt;
+	T_INTCB *p_intcb;
+
+	for(cnt = 0;cnt < TNUM_INT;cnt++)
+	{
+		p_intcb = &(intcbs[cnt]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_intcb->intno)
+		{
+			(p_intcb->inthdr)();
+			p_intcb->intatr = 0;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+
+	return E_OK;
+}
+
+ER set_int(UINT intno)
+{
+	ER result;
+
+	if(ISVALID_INTNO(intno))
+	{
+		T_INTCB *p_intcb;
+
+		p_intcb = &(intcbs[intno]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_intcb->intno)
+		{
+			p_intcb->intatr = 1;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+
+/* 割込みハンドラ定義 */
+ER def_int(UINT dintno, T_DINT *pk_dint)
+{
+	ER result;
+
+	if(ISVALID_INTNO(dintno))
+	{
+		T_INTCB *p_intcb;
+
+		p_intcb = &(intcbs[dintno]);
+
+		depend_EnterCriticalSection();
+
+		if(ISVALID_PTR(pk_dint))
+		{
+			if(ISVALID_INTATR(intatr))
+			{
+				if(0 == p_intcb->intno)
+				{
+					*p_intcb = intcb_initializer;
+
+					p_intcb->intno = dintno;
+
+					p_intcb->intatr = pk_dint->intatr;
+					p_intcb->inthdr = pk_dint->inthdr;
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_OBJ;
+				}
+			}
+			else
+			{
+				result = E_RSATR;
+			}
+		}
+		else
+		{
+			*p_intcb = intcb_initializer;
+
+			result = E_OK;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+void ret_int(void)
+{
+}
+
+void ret_wup(ID tskid)
+{
+
+}
+
+/* 割込みとディスパッチの禁止 */
+ER loc_cpu(void)
+{
+	return E_NOSPT;
+}
+
+/* 割込みとディスパッチの許可 */
+ER unl_cpu(void)
+{
+	return E_NOSPT;
+}
+
+/* 割込み禁止 */
+ER dis_int(UINT eintno)
+{
+	return E_NOSPT;
+}
+
+/* 割込み許可 */
+ER ena_int(UINT eintno)
+{
+	return E_NOSPT;
+}

--- /dev/null
+++ b/src/int.h
@@ -0,0 +1,13 @@
+#ifndef _INT_H_
+#define _INT_H_
+
+#include <itron.h>
+
+ER int_initialize(void);
+void int_terminate(void);
+
+ER int_event(void);
+
+ER set_int(UINT intno);
+
+#endif /* INT_H_ */

--- /dev/null
+++ b/src/it3.c
@@ -0,0 +1,213 @@
+#include "it3.h"
+#include "it3_common.h"
+#include "it3_debug.h"
+
+#define EXTDEF
+#include "kernel.h"
+#undef EXTDEF
+
+#include "tsk.h"
+#include "sem.h"
+#include "flg.h"
+#include "mbx.h"
+#include "mbf.h"
+#include "por.h"
+#include "int.h"
+#include "mpl.h"
+#include "mpf.h"
+#include "tim.h"
+#include "alm.h"
+#include "cyc.h"
+#include "sys.h"
+#include "net.h"
+
+static ER (*init_funcs[])(void) = {
+		tsk_initialize,
+		sem_initialize,
+		flg_initialize,
+		mbx_initialize,
+		mbf_initialize,
+		por_initialize,
+		int_initialize,
+		mpl_initialize,
+		mpf_initialize,
+		tim_initialize,
+		alm_initialize,
+		cyc_initialize,
+		sys_initialize,
+		net_initialize,
+};
+
+static void (*term_funcs[])(void) = {
+		net_terminate,
+		sys_terminate,
+		cyc_terminate,
+		alm_terminate,
+		tim_terminate,
+		mpf_terminate,
+		mpl_terminate,
+		int_terminate,
+		por_terminate,
+		mbf_terminate,
+		mbx_terminate,
+		flg_terminate,
+		sem_terminate,
+		tsk_terminate,
+};
+
+/* カーネルの初期化 */
+static ER it3_initialize(void)
+{
+	ER result;
+	INT cnt, cnt_max;
+	int int_ret;
+	ER er_ret;
+
+	/* 環境依存部分の初期化 */
+	int_ret = depend_initialize();
+	if(0 == int_ret)
+	{
+		result = E_OK;
+
+		cnt_max = ARRAY_CNT(init_funcs);
+		for(cnt = 0;cnt < cnt_max;cnt++)
+		{
+			er_ret = (init_funcs[cnt])();
+			if(E_OK != er_ret)
+			{
+				IT3_LOG2("it3 init failure.[cnt:%d, ret:%d]", cnt, er_ret);
+				result = er_ret;
+				break;
+			}
+		}
+	}
+	else
+	{
+		IT3_LOG1("it3 depend init abort.[ret:%d]", int_ret);
+		result = E_SYS;
+	}
+
+	return result;
+}
+
+/* カーネル実行 */
+static int it3_run(void)
+{
+	/* システム時刻を初期化 */
+
+	/* 割り込みを許可 */
+
+	/* タスクの実行開始 */
+	/* 全てのタスクがDOMANT状態になったら、終了する */
+	while(TRUE)
+	{
+		/* 割込みハンドラ */
+		int_event();
+
+		/* タイムイベントハンドラ */
+		tim_event();
+
+		/* CPU例外ハンドラ */
+		/* 拡張サービスコールルーチン */
+		/* タスク */
+
+//		if()	/* 全てのタスクがDOMANT? */
+//		{
+//			break;
+//		}
+
+		/* タスクをディスパッチ */
+		tsk_dispatch();
+	}
+
+	depend_message_show("uITRONを終わるYO！");
+
+	/* 環境依存部分の終了 */
+	depend_terminate();
+
+	return E_OK;
+}
+
+/* カーネルの終了処理 */
+static void it3_terminate(void)
+{
+	INT cnt, cnt_max;
+
+	cnt_max = ARRAY_CNT(term_funcs);
+	for(cnt = 0;cnt < cnt_max;cnt++)
+	{
+		(term_funcs[cnt])();
+	}
+
+	depend_terminate();
+}
+
+/* カーネルのエントリーポイント */
+ER IT3_main(const T_IT3_ARG *p_arg)
+{
+	int result;
+	ER ret;
+
+	it3_debug_initialize();
+
+	IT3_LOG("-->it3_main");
+
+	/* ハードウェア依存の初期化処理 */
+	ret = (ISVALID_PTR(p_arg->pf_hw_init)) ? (p_arg->pf_hw_init)() : E_OK;
+	if(E_OK == ret)
+	{
+		/* カーネル自身の初期化処理 */
+		ret = it3_initialize();
+		if(E_OK == ret)
+		{
+			/* 静的APIの処理 */
+			/* 今のところ静的APIは未実装なので、することが無い */
+
+			/* ユーザースタートアップ */
+			ret = (p_arg->pf_startup)();
+			if(E_OK == ret)
+			{
+				/* カーネルの動作開始 */
+				it3_run();
+
+				result = E_OK;
+			}
+			else
+			{
+				IT3_LOG1("user startup failure[ret:%d].", ret);
+				result = ret;
+			}
+
+			/* カーネルの終了 */
+			it3_terminate();
+		}
+		else
+		{
+			IT3_LOG1("it3 init failure.[ercd:%d]", ret);
+			result = ret;
+		}
+
+		/* ハードウェアの終了処理 */
+		if(ISVALID_PTR(p_arg->pf_hw_term))
+		{
+			(p_arg->pf_hw_term)();
+		}
+	}
+	else
+	{
+		IT3_LOG1("hardware init failure.[ret:%d]", ret);
+		result = ret;
+	}
+
+	IT3_LOG("<--it3_main");
+
+	it3_debug_terminate();
+
+	return result;
+}
+
+/* 割込み信号設定 */
+ER IT3_interrupt_signel(UINT intno)
+{
+	return set_int(intno);
+}

--- /dev/null
+++ b/src/it3_common.h
@@ -0,0 +1,16 @@
+#ifndef _IT3_COMMON_H_
+#define _IT3_COMMON_H_
+
+#include <itron.h>
+
+#ifdef NULL
+#undef NULL
+#endif /* NULL */
+#define	NULL	((void *)0)
+
+#define	ISVALID_PTR(ptr)		((NULL != (ptr)) && (((void *)NADR) != (ptr)))
+#define	ISVALID_TMOUT(tmout)	((0 < (tmout)) || (TMO_FEVR == (tmout)) || (TMO_POL == (tmout)))
+
+#define	ARRAY_CNT(ar)			(sizeof(ar) / sizeof(ar[0]))
+
+#endif /* _IT3_COMMON_H_ */

--- /dev/null
+++ b/src/it3_config.h
@@ -0,0 +1,180 @@
+#ifndef _IT3_CONFIG_H_
+#define _IT3_CONFIG_H_
+
+/* task */
+
+/* Number of tasks */
+#define	TNUM_TSK		(256)
+
+/* semaphore */
+/* Number of semaphore */
+#define	TNUM_SEM		(256)
+
+/* event flag */
+/* Number of event flags */
+#define	TNUM_FLG		(256)
+
+
+/* data queue */
+/* Number of data queue */
+#define	TNUM_DTQ		(256)
+
+
+/* mail box */
+/* Number of mail box */
+#define	TNUM_MBX		(256)
+
+
+/* mutex */
+/* Number of mutex */
+#define	TNUM_MTX		(256)
+
+
+/* message buffer */
+/* Number of message buffer */
+#define	TNUM_MBF		(256)
+
+
+/* rendezvous port */
+/* Number of rendezvous port */
+#define	TNUM_POR		(256)
+
+
+/* fixed-sized memory pool */
+/* Number of fixed-sized memory pool */
+#define	TNUM_MPF		(256)
+
+
+/* memory pool */
+/* Number of memory pool */
+#define	TNUM_MPL		(256)
+
+
+/* cyclic handler */
+/* Number of cyclic handler */
+#define	TNUM_CYC		(256)
+
+
+/* alarm handler */
+/* Number of alarm handler */
+#define	TNUM_ALM		(256)
+
+
+/* overrun handler */
+/* Number of overrun handler */
+#define	TNUM_OVR		(256)
+
+
+/* interrupt service routine */
+/* Number of interrupt handler */
+#define	TNUM_INH		(256)
+/* Number of interrupt service routine */
+#define	TNUM_ISR		(256)
+/* Number of interrupt number */
+#define	TNUM_INT		(256)
+
+
+/* super viser call */
+/* Number of super viser call */
+#define	TNUM_SVC		(256)
+
+
+/* CPU exception handler */
+/* Number of cpu exception handler */
+#define	TNUM_EXC		(256)
+
+/* Minimum value of task priority */
+#define	TMIN_TPRI		(1)
+/* Maximum value of task priority */
+#define	TMAX_TPRI		(16)
+
+/* Minimum value of message priority */
+#define	TMIN_MPRI		(1)
+/* Maximum value of message priority */
+#define	TMAX_MPRI		(16)
+
+/* Maker code of kernel */
+#define	TKERNEL_MAKER		(0x0000)
+/* Production ID of kernel */
+#define	TKERNEL_PRID		(0x0000)
+/*
+ * ITRON spec version.
+ *
+ * 0xABBB
+ *
+ * A - TRON spec kind.
+ * 0x0 TRON共通の仕様(TADなど)
+ * 0x1 ITRON仕様(ITRON1,ITRON2)
+ * 0x2 BTRON仕様
+ * 0x3 CTRON仕様
+ * 0x5 μITRON仕様(μITRON2.0,μITRON3.0,μITRON4.0)
+ * 0x6 μBTRON仕様
+ *
+ * BBB - spec version.(BCD)
+ *
+ * ex) uITRON 03.02.02  => 0x5322
+ */
+#define	TKERNEL_SPVER		(0x5322)
+/* Produnction version of kernel */
+#define	TKERNEL_PRVER		(0x0000)
+/* Production number of kernel */
+#define	TKERNEL_PRNO0		(0x0000)
+#define	TKERNEL_PRNO1		(0x0000)
+#define	TKERNEL_PRNO2		(0x0000)
+#define	TKERNEL_PRNO3		(0x0000)
+/* CPU information */
+#define	TKERNEL_CPU			(0x0000)
+/* Variation of kernel */
+#define	TKERNEL_VAR			(0x0000)
+
+/* Maximum value of task wake-up-request count */
+#define	TMAX_WUPCNT		(16)
+/* Maximum value of task force-wait-request nest count */
+#define	TMAX_SUSCNT		(16)
+
+/* Number of bits of task exception factor */
+#define	TBIT_TEXPTN			(16)
+/* Number of bits of event flag */
+#define	TBIT_FLGPTN			(16)
+/* Number of bits of rendezvous condition */
+#define	TBIT_RDVPTN			(16)
+
+/* numerator of period of time tick */
+#define	TIC_NUME			(1)
+/* denominator of period of time tick */
+#define	TIC_DENO			(1)
+
+/* Size of data-queue-area required to store pieces of dtqcnt (bytes) */
+#define	TSZ_DTQ(dtqcnt)		((SIZE)((UINT)(dtqcnt) * 1))
+/* 送信されるメッセージの優先度の最大値が maxmpri のメールボックスに
+必要な優先度別メッセージキューヘッダ領域のサイズ(バイト数)
+SIZE mprihdsz = TSZ_MPRIHD ( PRI maxmpri ) */
+#define	TSZ_MPRIHD(maxmpri)	((SIZE)((PRI)(maxmpri) * 4 ))
+/* サイズが msgsz バイトのメッセージを msgcnt 個バッファリングするのに
+必要なメッセージバッファ領域のサイズ(目安のバイト数)
+SIZE mbfsz = TSZ_MBF ( UINT msgcnt, UINT msgsz ) */
+#define	TSZ_MBF(msgcnt, msgsz)	((SIZE)((UINT)(msgcnt) * (UINT)(msgsz)))
+/* サイズがblkszバイトのメモリブロックをblkcnt個獲得できるのに必要な
+固定長メモリプール領域のサイズ(バイト数)
+SIZE mpfsz = TSZ_MPF ( UINT blkcnt, UINT blksz ) */
+#define	TSZ_MPF(blkcnt, blksz)	((SIZE)((UINT)(blkcnt) * (UINT)(blksz)))
+/* サイズがblkszバイトのメモリブロックをblkcnt個獲得できるのに必要な
+可変長メモリプール領域のサイズ(目安のバイト数)
+SIZE mplsz = TSZ_MPL ( UINT blkcnt, UINT blksz ) */
+#define	TSZ_MPL(blkcnt, blksz)	((SIZE)((UINT)(blkcnt) * (UINT)(blksz)))
+
+/* Maximum of maximum resource number of semaphore */
+#define	TMAX_MAXSEM			(256)
+
+
+
+
+/*--------------------------------------------------------------------------*/
+/* uITRONシミュレーションカーネルのログ出力									*/
+/*		0	:	カーネルログを出力しない									*/
+/*		1	:	カーネルログを出力する										*/
+/*--------------------------------------------------------------------------*/
+#define		UITRON_KERNEL_LOG				1
+
+
+#endif /* _IT3_CONFIG_H_ */

--- /dev/null
+++ b/src/it3_debug.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include "it3_debug.h"
+
+/* デバッグシステムの初期化 */
+int it3_debug_initialize(void)
+{
+	return 0;
+}
+
+/* デバッグシステムの終了 */
+void it3_debug_terminate(void)
+{
+}
+
+void it3_debug_printf(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	va_end(ap);
+}
+
+void it3_debug_assert(void)
+{
+
+}

--- /dev/null
+++ b/src/it3_debug.h
@@ -0,0 +1,34 @@
+#ifndef _IT3_DEBUG_H_
+#define _IT3_DEBUG_H_
+
+/* デバッグシステムの初期化 */
+int it3_debug_initialize(void);
+
+/* デバッグシステムの終了 */
+void it3_debug_terminate(void);
+
+#ifdef _DEBUG
+
+extern void it3_debug_printf(const char *fmt, ...);
+
+#define	IT3_ASSERT(s)	{if(! (s)){ it3_debug_printf("Assert!:(" #s "), %s:%d\n", __FILE__, __LINE__); }}
+
+#define	IT3_LOG(s)						it3_debug_printf("[IT3] " s "\n")
+#define	IT3_LOG1(fmt, p1)				it3_debug_printf("[IT3] " fmt "\n", (p1))
+#define	IT3_LOG2(fmt, p1, p2)			it3_debug_printf("[IT3] " fmt "\n", (p1), (p2))
+#define	IT3_LOG3(fmt, p1, p2, p3)		it3_debug_printf("[IT3] " fmt "\n", (p1), (p2), (p3))
+#define	IT3_LOG4(fmt, p1, p2, p3, p4)	it3_debug_printf("[IT3] " fmt "\n", (p1), (p2), (p3), (p4))
+
+#else /* _DEBUG */
+
+#define	IT3_ASSERT(s)
+
+#define	IT3_LOG(s)
+#define	IT3_LOG1(fmt, p1)
+#define	IT3_LOG2(fmt, p1, p2)
+#define	IT3_LOG3(fmt, p1, p2, p3)
+#define	IT3_LOG4(fmt, p1, p2, p3, p4)
+
+#endif /* _DEBUG */
+
+#endif /* _IT3_DEBUG_H_ */

--- /dev/null
+++ b/src/kernel.h
@@ -0,0 +1,47 @@
+#ifndef _KERNEL_H_
+#define _KERNEL_H_
+
+#include "it3_config.h"
+
+#include <itron.h>
+
+/* カーネルデバッグ */
+//#include "kernel_debug.h"
+
+/* タスクモジュール */
+#include "tsk.h"
+
+#include "tim.h"
+
+#include "depend.h"
+
+
+#if (DEPEND_TSK_NUM != TSKNUM)
+/* 環境依存部分とシミュレーション部分のタスク数が異なっているYO！*/
+#error DEPEND_TSK_NUM not equal TSKNUM
+#endif /* (DEPEND_TSK_NUM != TSKNUM) */
+
+
+
+/* カーネル内主関数 */
+/* カーネルの初期化 */
+int kernel_initialize(void);
+
+/* カーネル実行 */
+int kernel_run(void);
+
+/* カーネルの終了処理 */
+int kernel_terminate(void);
+
+#ifdef EXTDEF
+#define EXTERN 
+#else /* EXTDEF */
+#define EXTERN extern
+#endif /* EXTDEF */
+
+EXTERN T_TCB tcb[TNUM_TSK];
+EXTERN T_TCBTMO tcbtmoq[TNUM_TSK];
+EXTERN T_LST rdq[TNUM_TSK];
+EXTERN T_TIMQ timq;
+
+#endif /* _KERNEL_H_ */

--- /dev/null
+++ b/src/kernel_etc.c
@@ -0,0 +1,73 @@
+#include <stdio.h>
+
+#include "kernel.h"
+
+#include "sem.h"
+
+#include "que_ctl.h"
+
+
+#if 0 // TODO
+
+/*--------------------------------------------------------------------------*/
+/*                         強制中断要求をマスクする                         */
+/*--------------------------------------------------------------------------*/
+ER sus_mask(void)
+{
+	ER ercd;
+	T_TCB *p_tcb;
+
+	ercd = kernel_tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	p_tcb->susmask = MASK;		/* マスク状態設定 */
+
+	return E_OK;
+}
+
+/*--------------------------------------------------------------------------*/
+/*                        強制中断要求マスクを解除する                      */
+/*--------------------------------------------------------------------------*/
+ER sus_free(void)
+{
+	ER ercd;
+	T_TCB *p_tcb;
+
+	ercd = kernel_tsk_get_tcb(TSK_SELF, &p_tcb);
+
+	if(p_tcb->susmask == FREE )		/* マスク状態でない */
+	{
+		return E_NGMASK;
+	}
+
+	p_tcb->susmask = FREE;		/* マスク状態解除 */
+
+	if(0 == p_tcb->suscnt)		/* 強制中断要求が１度も無かった場合 */
+	{
+		return E_NGSUS;
+	}
+
+	/* 強制中断要求がキューイングされている場合 */
+
+	(p_tcb->suscnt)--;
+
+	del_rdq(p_tcb);								/* RDQ から TCB を外す		*/
+	p_tcb->tskstat = TTS_SUS;							/* タスク状態をSUSPENDに	*/
+
+	/* ディスパッチされるまで待つ */
+	kernel_tsk_wait_dispatch();
+
+	return E_OK;
+}
+
+#endif
+
+
+
+
+
+
+

--- /dev/null
+++ b/src/lst.h
@@ -0,0 +1,101 @@
+#ifndef _LST_H_
+#define _LST_H_
+
+#include <itron.h>
+
+#define INLINE __inline
+
+typedef struct S_LST {
+	struct S_LST	*p_next;
+	struct S_LST	*p_prev;
+} T_LST;
+
+/**
+ * initialize list.
+ */
+INLINE void lst_init(T_LST *p_lst)
+{
+	p_lst->p_prev = p_lst->p_next = p_lst;
+}
+
+/**
+ * list insert item.
+ *  p_lst の直前に entry を挿入する.
+ *  p_lst がキューヘッダを指す場合には，キューの最後尾に entry を挿入することになる．
+ */
+INLINE void lst_insert(T_LST *p_lst, T_LST *p_item)
+{
+	p_item->p_prev = p_lst->p_prev;
+	p_item->p_next = p_lst;
+	p_lst->p_prev->p_next = p_item;
+	p_lst->p_prev = p_item;
+}
+
+/*
+ *  キューからエントリを削除
+ *
+ *  entry をキューから削除する．
+ */
+INLINE void lst_delete(T_LST *p_item)
+{
+	if (p_item->p_next != p_item)
+	{
+		p_item->p_prev->p_next = p_item->p_next;
+		p_item->p_next->p_prev = p_item->p_prev;
+	}
+}
+
+/*
+ *  キューの先頭のエントリの取り出し
+ *
+ *  p_lst の直後のエントリをキューから削除し，削除したエントリを返す．
+ *  p_lst がキューヘッダを指す場合には，キューの先頭のエントリを取り出
+ *  すことになる．
+ */
+INLINE T_LST * lst_delete_next(T_LST *p_lst)
+{
+	T_LST *p_item;
+
+	if (p_lst->p_next != p_lst)
+	{
+		p_item = p_lst->p_next;
+		p_lst->p_next = p_item->p_next;
+		p_item->p_next->p_prev = p_lst;
+	}
+	else
+	{
+		p_item = (void *)NADR;
+	}
+
+	return (p_item);
+}
+
+/*
+ *  キュー中のエントリのサーチ
+ *
+ *  p_lst で示すキューから，offset で示すフィールドが val より大きいの
+ *  エントリをサーチし，そのエントリを返す．該当するエントリがない場合
+ *  は，p_lst を返す．
+ */
+INLINE T_LST * lst_search_gt(T_LST *p_lst, INT val, INT offset)
+{
+	T_LST *entry;
+
+	for (entry = p_lst->p_next; entry != p_lst; entry = entry->p_next) {
+		if (*((INT *)(((VB *) entry) + offset)) > val) {
+			break;
+		}
+	}
+
+	return(entry);
+}
+
+/*
+ *  キューが空かどうかのチェック
+ */
+INLINE BOOL lst_empty(T_LST *p_lst)
+{
+	return ((p_lst->p_next == p_lst) ? TRUE : FALSE);
+}
+
+#endif /* _LST_H_ */

--- /dev/null
+++ b/src/mbf.c
@@ -0,0 +1,247 @@
+#include "mbf.h"
+#include "it3_common.h"
+#include "it3_config.h"
+
+#define	ISVALID_MBFID(mbfid)		((0 < (mbfid)) && ((mbfid) < TNUM_MBF))
+#define	ISVALID_MBFATR(mbfatr)		(TRUE)	/* 属性情報はチェックしない */
+
+typedef struct S_MBFCB
+{
+	ID						mbfid;
+
+	VP						exinf;			/* 拡張情報						*/
+	ATR						mbfatr;			/* メッセージバッファ属性			*/
+	INT						bufsz;			/* メッセージバッファのサイズ		*/
+	INT						maxmsz;			/* メッセージの最大長				*/
+
+} T_MBFCB;
+
+static const T_MBFCB mbfcb_initializer = {0};
+
+static T_MBFCB mbfcbs[TNUM_MBF];
+
+ER mbf_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_MBF;cnt++)
+	{
+		mbfcbs[cnt] = mbfcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void mbf_terminate(void)
+{
+}
+
+/* メッセージバッファ生成 */
+ER cre_mbf(ID mbfid, T_CMBF *pk_cmbf)
+{
+	ER result;
+
+	if(ISVALID_MBFID(mbfid))
+	{
+		if(ISVALID_PTR(pk_cmbf) && ISVALID_MBFATR(pk_cmbf->mbfatr))
+		{
+			T_MBFCB *p_mbfcb;
+
+			p_mbfcb = &(mbfcbs[mbfid]);
+
+			if(0 == p_mbfcb->mbfid)
+			{
+				*p_mbfcb = mbfcb_initializer;
+
+				p_mbfcb->mbfid = mbfid;
+				p_mbfcb->exinf = pk_cmbf->exinf;
+				p_mbfcb->mbfatr = pk_cmbf->mbfatr;
+				p_mbfcb->bufsz = pk_cmbf->bufsz;
+				p_mbfcb->maxmsz = pk_cmbf->maxmsz;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メッセージバッファ削除 */
+ER del_mbf(ID mbfid)
+{
+	ER result;
+
+	if(ISVALID_MBFID(mbfid))
+	{
+		T_MBFCB *p_mbfcb;
+
+		p_mbfcb = &(mbfcbs[mbfid]);
+
+		if(0 != p_mbfcb->mbfid)
+		{
+			*p_mbfcb = mbfcb_initializer;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メッセージバッファへ送信 */
+ER snd_mbf(ID mbfid, VP msg, INT msgsz)
+{
+	return tsnd_mbf(mbfid, msg, msgsz, TMO_FEVR);
+}
+
+/* メッセージバッファへ送信(ポーリング) */
+ER psnd_mbf(ID mbfid, VP msg, INT msgsz)
+{
+	return tsnd_mbf(mbfid, msg, msgsz, TMO_POL);
+}
+
+/* メッセージバッファへ送信(タイムアウト有) */
+ER tsnd_mbf(ID mbfid, VP msg, INT msgsz, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_MBFID(mbfid))
+	{
+		if(ISVALID_PTR(msg) && (0 < msgsz) && ISVALID_TMOUT(tmout))
+		{
+			T_MBFCB *p_mbfcb;
+
+			p_mbfcb = &(mbfcbs[mbfid]);
+
+			if(0 != p_mbfcb->mbfid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メッセージバッファから受信 */
+ER rcv_mbf(VP msg, INT *p_msgsz, ID mbfid)
+{
+	return trcv_mbf(msg, p_msgsz, mbfid, TMO_FEVR);
+}
+
+/* メッセージバッファから受信(ポーリング) */
+ER prcv_mbf(VP msg, INT *p_msgsz, ID mbfid)
+{
+	return trcv_mbf(msg, p_msgsz, mbfid, TMO_POL);
+}
+
+/* メッセージバッファから受信(タイムアウト有) */
+ER trcv_mbf(VP msg, INT *p_msgsz, ID mbfid, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_MBFID(mbfid))
+	{
+		if(ISVALID_PTR(msg) && ISVALID_PTR(p_msgsz) && ISVALID_TMOUT(tmout))
+		{
+			T_MBFCB *p_mbfcb;
+
+			p_mbfcb = &(mbfcbs[mbfid]);
+
+			if(0 != p_mbfcb->mbfid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メッセージバッファ状態参照 */
+ER ref_mbf(T_RMBF *pk_rmbf, ID mbfid)
+{
+	ER result;
+
+	if(ISVALID_MBFID(mbfid))
+	{
+		if(ISVALID_PTR(pk_rmbf))
+		{
+			T_MBFCB *p_mbfcb;
+
+			p_mbfcb = &(mbfcbs[mbfid]);
+
+			if(0 != p_mbfcb->mbfid)
+			{
+				pk_rmbf->exinf = p_mbfcb->exinf;
+				pk_rmbf->wtsk = FALSE;		// TODO どうしよっかなー
+				pk_rmbf->stsk = FALSE;		// TODO どうしよっかなー
+				pk_rmbf->msgsz = 0;			// TODO どうしよっかなー
+				pk_rmbf->frbufsz = 0;		// TODO どうしよっかなー
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/mbf.h
@@ -0,0 +1,9 @@
+#ifndef _MBF_H_
+#define _MBF_H_
+
+#include <itron.h>
+
+ER mbf_initialize(void);
+void mbf_terminate(void);
+
+#endif /* _MBF_H_ */

--- /dev/null
+++ b/src/mbx.c
@@ -0,0 +1,753 @@
+#include "mbx.h"
+#include "it3_common.h"
+#include "it3_debug.h"
+#include "lst.h"
+
+#include "kernel.h"
+#include "que_ctl.h"
+
+
+#define	ISVALID_MBXID(mbxid)	((0 < (mbxid)) && ((mbxid) < TNUM_MBX))
+#define	ISVALID_MBXATR(mbxatr)	(TRUE)	/* 属性値はチェックしない */
+
+/* メイルボックスキュー管理ブロック(MBXQ) */
+typedef struct S_MBXCB
+{
+	ID			mbxid;
+
+	VP 			exinf;
+	ATR			mbxatr;
+	INT			bufcnt;
+
+	T_LST		wtsklst;
+
+	T_MSG		*p_mhead;
+
+
+	T_TCB		*head;					/* 先頭TCBへのポインタ				*/
+	T_MSG		*msg;					/* 先頭メッセージへのポインタ		*/
+	VH			wtskmode;				/* 待ち順序							*/
+	VH			wmsgmode;				/* 待ち順序							*/
+	VB			dmy[4];					/* ダミー							*/
+} T_MBXCB;
+
+
+static const T_MBXCB mbxcb_initializer = {0};
+
+static T_MBXCB mbxcbs[TNUM_MBX];
+
+/*--------------------------------------------------------------------------*/
+/*                   メッセージ待ちキューにタスクを追加                     */
+/*--------------------------------------------------------------------------*/
+static void add_mbxq(T_MBXCB *p_mbxcb, T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_mbxcb);
+	IT3_ASSERT(p_tcb);
+
+	if(TA_TPRI & p_mbxcb->mbxatr)
+	{
+		T_LST *p_insert_pos;
+
+		p_insert_pos = p_mbxcb->wtsklst.p_next;
+
+		while(&(p_mbxcb->wtsklst) != p_insert_pos)
+		{
+			if(p_tcb->tskpri < ((T_TCB *)p_insert_pos)->tskpri)
+			{
+				break;
+			}
+
+			p_insert_pos = p_insert_pos->p_next;
+		}
+
+		lst_insert(p_insert_pos, (T_LST *)p_tcb);
+	}
+	else
+	{
+		lst_insert(&(p_mbxcb->wtsklst), (T_LST *)p_tcb);
+	}
+
+#if 0 // lstに変える
+	T_MBXCB *p_mbxq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_mbxq = &(mbxcbs[p_tcb->wid]);
+
+	toptcb = p_mbxq->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		if(p_mbxq->wtskmode == TA_TFIFO)	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			p_tcb->prev = endtcb;
+			p_tcb->next = toptcb;
+			toptcb->prev = p_tcb;
+			endtcb->next = p_tcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( p_tcb->pri < nextcb->pri )
+				{
+					pretcb = nextcb->prev;
+
+					p_tcb->prev = pretcb;
+					p_tcb->next = nextcb;
+					nextcb->prev = p_tcb;
+					pretcb->next = p_tcb;
+
+					if( nextcb == toptcb )
+					{
+						p_mbxq->head = p_tcb;
+					}
+					break;
+				}
+
+				nextcb = nextcb->next;
+
+			} while( (nextcb != toptcb)&&(mbxcbs->head != NULL) );
+
+			if( nextcb == toptcb )
+			{
+				p_tcb->prev = endtcb;
+				p_tcb->next = toptcb;
+				toptcb->prev = p_tcb;
+				endtcb->next = p_tcb;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		mbxcbs->head   = p_tcb;
+		p_tcb->next = p_tcb;
+		p_tcb->prev = p_tcb;
+	}
+
+	return;
+#endif
+}
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージ待ちキューからタスクを削除                    */
+/*--------------------------------------------------------------------------*/
+static void del_mbxq(T_MBXCB *p_mbxcb, T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_tcb);
+
+	lst_delete((T_LST *)p_tcb);
+
+#if 0 // lstに変える
+	T_MBXCB *p_mbxq;
+	T_TCB *pretcb, *nextcb;
+
+	p_mbxq = &(mbxcbs[deltcb->wid]);
+
+	pretcb = deltcb->prev;
+	if(pretcb != deltcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+		if(p_mbxq->head == deltcb)
+		{
+			mbxcbs->head = nextcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		mbxcbs->head = NULL;
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+#endif
+}
+
+/*--------------------------------------------------------------------------*/
+/*                   メッセージキューにメッセージを追加                     */
+/*--------------------------------------------------------------------------*/
+void add_msg(ID mbxid, T_MSG *addmsg)
+{
+	T_MBXCB *p_mbxq;
+	T_MSG *topmsg, *endmsg, *nexmsg, *premsg;
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	topmsg = mbxcbs->msg;
+	if(topmsg != NULL)
+	{
+		/*-------------------- 他のメッセージがある --------------------*/
+		if( mbxcbs->wmsgmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endmsg       = topmsg->pk_prev;
+			addmsg->pk_prev = endmsg;
+			addmsg->pk_next = topmsg;
+			topmsg->pk_prev = addmsg;
+			endmsg->pk_next = addmsg;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endmsg = topmsg->pk_prev;
+			nexmsg = topmsg;
+
+			do
+			{
+				if( tcb[addmsg->tskid].tskpri < tcb[nexmsg->tskid].tskpri )
+				{
+					premsg = nexmsg->pk_prev;
+
+					addmsg->pk_prev = premsg;
+					addmsg->pk_next = nexmsg;
+					nexmsg->pk_prev = addmsg;
+					premsg->pk_next = addmsg;
+
+					if( nexmsg == topmsg )
+					{
+						mbxcbs->msg = addmsg;
+					}
+
+					break;
+				}
+
+				nexmsg = nexmsg->pk_next;
+
+			} while( (nexmsg != topmsg)&&(mbxcbs->msg != NULL) );
+
+			if( nexmsg == topmsg )
+			{
+				addmsg->pk_prev = endmsg;
+				addmsg->pk_next = topmsg;
+				topmsg->pk_prev = addmsg;
+				endmsg->pk_next = addmsg;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のメッセージがない --------------------*/
+		mbxcbs->msg    = addmsg;
+		addmsg->pk_next = addmsg;
+		addmsg->pk_prev = addmsg;
+	}
+
+	return;
+}
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージキューからメッセージを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_msg(ID mbxid, T_MSG *delmsg)
+{
+	T_MBXCB *p_mbxq;
+	T_MSG *premsg, *nexmsg;
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	premsg = delmsg->pk_prev;
+	if(premsg != delmsg )
+	{
+		/*-------------------- 他のメッセージがある --------------------*/
+		nexmsg       = delmsg->pk_next;
+		premsg->pk_next = nexmsg;
+		nexmsg->pk_prev = premsg;
+
+		if(p_mbxq->msg == delmsg)
+		{
+			mbxcbs->msg = nexmsg;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のメッセージがない --------------------*/
+		p_mbxq->msg = NULL;
+	}
+
+	delmsg->pk_next  = NULL;
+	delmsg->pk_prev  = NULL;
+
+	return;
+}
+
+
+ER mbx_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_MBX;cnt++)
+	{
+		mbxcbs[cnt] = mbxcb_initializer;
+		lst_init(&(mbxcbs[cnt].wtsklst));
+	}
+
+	return E_OK;
+}
+
+void mbx_terminate(void)
+{
+}
+
+/* メイルボックス生成 */
+ER cre_mbx(ID mbxid, T_CMBX* pk_cmbx)
+{
+	ER result;
+
+	if(ISVALID_MBXID(mbxid))
+	{
+		if(ISVALID_PTR(pk_cmbx) && ISVALID_MBXATR(pk_cmbx->mbxatr))
+		{
+			T_MBXCB *p_mbxcb;
+
+			p_mbxcb = &(mbxcbs[mbxid]);
+
+			if(0 == p_mbxcb->mbxid)
+			{
+				*p_mbxcb = mbxcb_initializer;
+
+				p_mbxcb->mbxid = mbxid;
+
+				p_mbxcb->exinf = pk_cmbx->exinf;
+				p_mbxcb->mbxatr = pk_cmbx->mbxatr;
+				p_mbxcb->bufcnt = pk_cmbx->bufcnt;
+
+				lst_init(&(p_mbxcb->wtsklst));
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メイルボックス削除 */
+ER del_mbx(ID mbxid)
+{
+	ER result;
+
+	if(ISVALID_MBXID(mbxid))
+	{
+		T_MBXCB *p_mbxcb;
+
+		p_mbxcb = &(mbxcbs[mbxid]);
+
+		if(0 != p_mbxcb->mbxid)
+		{
+			// TODO どうしよっかなー
+
+			*p_mbxcb = mbxcb_initializer;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メイルボックスへ送信 */
+ER snd_msg(ID mbxid, T_MSG *pk_msg)
+{
+	ER result;
+
+	if(ISVALID_MBXID(mbxid))
+	{
+		if(ISVALID_PTR(pk_msg))
+		{
+			T_MBXCB *p_mbxcb;
+
+			p_mbxcb = &(mbxcbs[mbxid]);
+
+			// TODO どうしよっかなー
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+
+
+#if 0
+	T_MBXCB *p_mbxq;
+	T_TCB *p_tcb;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_MBXID(mbxid))
+	{
+		return E_ID;
+	}
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	if((0 != pk_msg->pk_next) || (0 != pk_msg->pk_prev))
+	{
+		/* ＯＳ管理領域が初期化されていない */
+		return E_PAR;
+	}
+
+	/* 送信タスクＩＤを記録 */
+	kernel_tsk_get_self_tskid(&(pk_msg->tskid));
+
+	if(NULL == mbxcbs->head)
+	{
+		/*---------------- メッセージ待ちのタスクがない -----------------*/
+		/* メッセージを待ち行列につなげる */
+		add_msg(mbxid, pk_msg);
+	}
+	else
+	{
+		/*---------------- メッセージ待ちのタスクがある -----------------*/
+		p_tcb = mbxcbs->head;
+
+		*((T_MSG **)(p_tcb->arg)) = pk_msg;	/* メッセージを渡す      */
+
+		del_mbxq(p_mbxq, p_tcb);			/* MBXQ から TCB を外す  */
+
+		if(p_tcb->tskstat & TTS_SUS)
+		{
+			/* 二重待ち状態 */
+			p_tcb->tskstat = TTS_SUS;		/* タスク状態を SUSPEND に */
+		}
+		else
+		{
+			/* メッセージ待ち状態 */
+			p_tcb->tskstat = TTS_RDY;		/* タスク状態を READY に */
+			p_tcb->tskwait = 0;
+			p_tcb->wid = 0;
+			add_rdq(p_tcb);		/* RDQ に TCB をつなげる */
+		}
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+#endif
+}
+
+/* メイルボックスへ送信（割り込みハンドラ専用） */
+ER isnd_msg(ID mbxid, T_MSG *pk_msg)
+{
+	return snd_msg(mbxid, pk_msg);
+}
+
+/* メイルボックスから受信 */
+ER rcv_msg(T_MSG **ppk_msg, ID mbxid)
+{
+	return trcv_msg(ppk_msg, mbxid, TMO_FEVR);
+
+#if 0
+	T_MBXCB *p_mbxq;
+	T_TCB *p_tcb;
+	T_MSG *p_msg;
+
+//	if( DSPENA == OFF )	{		/* ディスパッチ禁止状態 */
+//		return( E_CTX );
+//	}
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_MBXID(mbxid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	if(NULL != p_mbxq->msg)
+	{
+		/*----------------------- メッセージがある ----------------------*/
+		p_msg = p_mbxq->msg;
+		*pk_msg = (T_MSG *)p_msg;		/* メッセージを受け取る */
+
+		del_msg(mbxid, p_msg);		/* MBXQ から メッセージを外す */
+	}
+	else
+	{
+		ER ercd;
+
+		/*----------------------- メッセージがない ----------------------*/
+		ercd = kernel_tsk_get_tcb(TSK_SELF, &p_tcb);
+		if(E_OK != ercd)
+		{
+			return ercd;
+		}
+
+		del_rdq(p_tcb);			/* RDQ から TCB を外す */
+
+		p_tcb->tskstat = TTS_WAI;
+		p_tcb->tskwait = TTW_MBX;
+		p_tcb->wid = mbxid;
+
+		p_tcb->arg = (VB *)pk_msg;	/* 戻り値用のアドレスを保存 */
+		add_mbxq(p_tcb);		/* MBXQ に TCB をつなげる */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+#endif
+}
+
+/* メイルボックスから受信(ポーリング) */
+ER prcv_msg(T_MSG **ppk_msg, ID mbxid)
+{
+	return trcv_msg(ppk_msg, mbxid, TMO_POL);
+
+#if 0
+	T_MBXCB *p_mbxq;
+	T_MSG *p_msg;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_MBXID(mbxid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	if(NULL == p_mbxq->msg)						/* メッセージがない? */
+	{
+		return E_TMOUT;
+	}
+
+	/*----------------------- メッセージがある ----------------------*/
+	p_msg = mbxcbs->msg;
+	*pk_msg = (T_MSG *)p_msg;		/* メッセージを受け取る */
+
+	del_msg(mbxid, p_msg);		/* MBXQ から メッセージを外す */
+
+	return E_OK;
+#endif
+}
+
+/* メイルボックスから受信(タイムアウト有) */
+ER trcv_msg(T_MSG **ppk_msg, ID mbxid, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_MBXID(mbxid))
+	{
+		if(ISVALID_PTR(ppk_msg) && ISVALID_TMOUT(tmout))
+		{
+			T_MBXCB *p_mbxcb;
+
+			p_mbxcb = &(mbxcbs[mbxid]);
+
+			if(0 != p_mbxcb->mbxid)
+			{
+				if(p_mbxcb->p_mhead)
+				{
+					*ppk_msg = p_mbxcb->p_mhead;
+					p_mbxcb->p_mhead = p_mbxcb->p_mhead->pk_next;
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_TMOUT;
+					if(tmout != TMO_POL) {
+//						ctxtsk->wspec = (mbxcb->mbxatr & TA_TPRI) ?
+//								&wspec_mbx_tpri : &wspec_mbx_tfifo;
+//						ctxtsk->wercd = &ercd;
+//						ctxtsk->winfo.mbx.ppk_msg = ppk_msg;
+//						gcb_make_wait((GCB *) mbxcb, tmout);
+					}
+				}
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* メイルボックス状態参照 */
+ER ref_mbx(T_RMBX *pk_rmbx, ID mbxid)
+{
+	ER result;
+
+	if(ISVALID_MBXID(mbxid))
+	{
+		if(pk_rmbx)
+		{
+			T_MBXCB *p_mbxcb;
+
+			p_mbxcb = &(mbxcbs[mbxid]);
+
+			if(0 != p_mbxcb->mbxid)
+			{
+				pk_rmbx->exinf = p_mbxcb->exinf;
+				pk_rmbx->wtsk = TSK_GET_WTSKID(&(p_mbxcb->wtsklst));
+				pk_rmbx->pk_msg = NULL;		// TODO どうしよっかなー
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+
+}
+
+/*--------------------------------------------------------------------------*/
+/*                      メイルボックス状態を参照する                        */
+/*--------------------------------------------------------------------------*/
+ER mbx_sts(ID *p_wtskid, T_MSG **ppk_msg, ID mbxid)
+{
+	T_MBXCB *p_mbxq;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_MBXID(mbxid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	*ppk_msg  = (T_MSG *)NADR;
+	*p_wtskid = FALSE;
+
+	if(NULL != p_mbxq->head)
+	{
+		/* 待ちタスクがある */
+		*p_wtskid = p_mbxq->head->tskid;	/* 先頭の待ちタスクＩＤを設定 */
+	}
+	else if(NULL != p_mbxq->msg)
+	{
+		/* メッセージがある */
+		*ppk_msg = p_mbxq->msg;		/* 先頭のメッセージアドレスを設定 */
+	}
+
+	return E_OK;
+}
+
+/*--------------------------------------------------------------------------*/
+/*      自タスクが送信したメッセージを待ちキューから外す（終了処理専用）    */
+/*--------------------------------------------------------------------------*/
+ER edel_msg(ID mbxid)
+{
+	T_MBXCB *p_mbxq;
+	T_MSG *topmsg, *nextmsg, *msg;
+	UH msgnum, d_msgnum;
+	UH i;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if((mbxid < 0) || (TNUM_MBX <= mbxid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	d_msgnum = 0;
+
+	p_mbxq = &(mbxcbs[mbxid]);
+
+	if(NULL != p_mbxq->msg)
+	{
+		/*- メッセージがある -*/
+		ID tskid;
+		tskid = kernel_tsk_get_self_tskid(TSK_SELF);
+
+		topmsg = msg = p_mbxq->msg;
+
+		/* メッセージの数を数える */
+		msgnum = 0;
+		do
+		{
+			msgnum++;
+			msg = msg->pk_next;
+		} while(topmsg != msg);
+
+		msg = topmsg;
+
+		for(i = 0;i < msgnum;i++)
+		{
+			if(msg->tskid == tskid)
+			{
+				nextmsg = msg->pk_next;
+				del_msg(mbxid, msg);	/* MBXQ から メッセージを外す */
+				msg = nextmsg;
+				d_msgnum++;
+			}
+			else
+			{
+				msg = msg->pk_next;
+			}
+		}
+	}
+
+	if(0 == d_msgnum)
+	{
+		return E_OBJ;
+	}
+
+	return E_OK;
+}
+

--- /dev/null
+++ b/src/mbx.h
@@ -0,0 +1,9 @@
+#ifndef _MBX_H_
+#define _MBX_H_
+
+#include <itron.h>
+
+ER mbx_initialize(void);
+void mbx_terminate(void);
+
+#endif	/* _MBX_H_ */

--- /dev/null
+++ b/src/mpf.c
@@ -0,0 +1,371 @@
+#include "mpf.h"
+#include "it3_common.h"
+#include "it3_config.h"
+#include <depend.h>
+#include "tsk.h"
+
+#define	ISVALID_MPFID(mpfid)		((0 < (mpfid)) && ((mpfid) < TNUM_MPF))
+#define	ISVALID_MPFATR(mpfatr)		(0 == ((mpfatr) & ~(TA_TPRI)))
+#define	ISVALID_BLF(blf, p_mpf, mpfcnt, blfsz)		(0 == ((mpfatr) & ~(TA_TPRI)))
+
+typedef struct S_MPFCB
+{
+	ID						mpfid;
+
+	VP						exinf;			/* 拡張情報						*/
+	ATR						mpfatr;			/* メモリプール属性				*/
+	INT						mpfcnt;			/* メモリプール全体のブロック数	*/
+	INT						blfsz;			/* 固定長メモリブロックサイズ		*/
+
+	T_LST					wtsklst;		/* 待ちタスクリスト				*/
+	INT						frbcnt;			/* 空きブロックの数				*/
+	T_LST					frblst;			/* 空きブロックのリスト			*/
+	B						*p_mpf;			/* メモリプールのアドレス		*/
+} T_MPFCB;
+
+static const T_MPFCB mpfcb_initializer = {0};
+
+static T_MPFCB mpfcbs[TNUM_MPF];
+
+static void build_frblst(T_LST *p_frblst, B *p_mpf, INT mpfcnt, INT blfsz)
+{
+	INT cnt;
+
+	lst_init(p_frblst);
+
+	for(cnt = 0;cnt < mpfcnt;cnt++)
+	{
+		lst_insert(p_frblst, (T_LST *)(p_mpf + (blfsz * cnt)));
+	}
+}
+
+static BOOL is_valid_blf(VP blf, B *p_mpf, INT mpfcnt, INT blfsz)
+{
+	BOOL result = FALSE;
+
+	if((p_mpf <= (B *)blf) && ((B *)blf < (p_mpf + (mpfcnt * blfsz))))
+	{
+		if(0 == (((B *)blf - p_mpf) % blfsz))
+		{
+			result = TRUE;
+		}
+	}
+
+	return result;
+}
+
+ER mpf_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_MPF;cnt++)
+	{
+		mpfcbs[cnt] = mpfcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void mpf_terminate(void)
+{
+}
+
+ER cre_mpf(ID mpfid, T_CMPF *pk_cmpf)
+{
+	ER result;
+
+	if(ISVALID_MPFID(mpfid))
+	{
+		if(ISVALID_PTR(pk_cmpf) && ISVALID_MPFATR(pk_cmpf->mpfatr))
+		{
+			T_MPFCB *p_mpfcb;
+
+			p_mpfcb = &(mpfcbs[mpfid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 == p_mpfcb->mpfid)
+			{
+				B *p_mpf;
+
+				p_mpf = (B *)depend_malloc(pk_cmpf->blfsz * pk_cmpf->mpfcnt);
+				if(ISVALID_PTR(p_mpf))
+				{
+					*p_mpfcb = mpfcb_initializer;
+
+					p_mpfcb->mpfid = mpfid;
+
+					p_mpfcb->exinf = pk_cmpf->exinf;
+					p_mpfcb->mpfatr = pk_cmpf->mpfatr;
+					p_mpfcb->mpfcnt = pk_cmpf->mpfcnt;
+					p_mpfcb->blfsz = pk_cmpf->blfsz;
+
+					lst_init(&(p_mpfcb->wtsklst));
+					p_mpfcb->frbcnt = pk_cmpf->mpfcnt;
+					build_frblst(&(p_mpfcb->frblst), p_mpf, p_mpfcb->mpfcnt, p_mpfcb->blfsz);
+					p_mpfcb->p_mpf = p_mpf;
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_NOMEM;
+				}
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER del_mpf(ID mpfid)
+{
+	ER result;
+
+	if(ISVALID_MPFID(mpfid))
+	{
+		T_MPFCB *p_mpfcb;
+
+		p_mpfcb = &(mpfcbs[mpfid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_mpfcb->mpfid)
+		{
+			depend_free(p_mpfcb->p_mpf);
+
+			*p_mpfcb = mpfcb_initializer;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER get_blf(VP *p_blf, ID mpfid)
+{
+	return tget_blf(p_blf, mpfid, TMO_FEVR);
+}
+
+ER pget_blf(VP *p_blf, ID mpfid)
+{
+	return tget_blf(p_blf, mpfid, TMO_POL);
+}
+
+ER ipget_blf(VP *p_blf, ID mpfid)
+{
+	return E_NOSPT;
+}
+
+ER tget_blf(VP *p_blf, ID mpfid, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_MPFID(mpfid))
+	{
+		if(ISVALID_PTR(p_blf) && ISVALID_TMOUT(tmout))
+		{
+			T_MPFCB *p_mpfcb;
+
+			p_mpfcb = &(mpfcbs[mpfid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 != p_mpfcb->mpfid)
+			{
+				if(lst_empty(&(p_mpfcb->wtsklst)))
+				{
+					if(TMO_POL != tmout)
+					{
+#if 0
+						T_TCB *p_tcb;
+						ER ret;
+
+						ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+						if(E_OK == ret)
+						{
+							del_rdq(NULL, p_tcb);
+							p_tcb->tskstat = TTS_WAI;
+							p_tcb->tskwait = TTW_MPF;
+							p_tcb->wid = mpfid;
+							lst_insert(&(p_mpfcb->wtsklst), (T_LST *)p_tcb);
+							result = tsk_wait(p_tcb);
+							if(E_OK == result)
+							{
+								*p_blf = p_tcb->wait.wmpf.blf;
+							}
+						}
+						else
+						{
+							result = ret;
+						}
+#endif
+						// TODO 空きが無いので待つ
+						result = E_NOSPT;
+					}
+					else
+					{
+						result = E_TMOUT;
+					}
+				}
+				else
+				{
+					T_LST *p_frb;
+
+					p_frb = p_mpfcb->wtsklst.p_next;
+					lst_delete(p_frb);
+					(p_mpfcb->frbcnt)--;
+
+					*p_blf = (VP)p_frb;
+
+					result = E_OK;
+				}
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER rel_blf(ID mpfid, VP blf)
+{
+	ER result;
+
+	if(ISVALID_MPFID(mpfid))
+	{
+		if(ISVALID_PTR(blf))
+		{
+			T_MPFCB *p_mpfcb;
+
+			p_mpfcb = &(mpfcbs[mpfid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 != p_mpfcb->mpfid)
+			{
+				if(is_valid_blf(blf, p_mpfcb->p_mpf, p_mpfcb->mpfcnt, p_mpfcb->blfsz))
+				{
+					if(lst_empty(&(p_mpfcb->wtsklst)))
+					{
+						lst_insert(&(p_mpfcb->frblst), (T_LST *)blf);
+						(p_mpfcb->frbcnt)++;
+					}
+					else
+					{
+#if 0
+						T_TCB *p_tcb;
+
+						p_tcb = (T_TCB *)(p_mpfcb->wtsklst.p_next);
+						p_tcb->winfo.mpf.blf = blf;
+						tsk_wait_release(p_tcb, E_OK);
+#endif
+						// TODO どうしよっかなー
+						result = E_NOSPT;
+					}
+					result = E_OK;
+				}
+				else
+				{
+					result = E_PAR;
+				}
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER ref_mpf(T_RMPF *pk_rmpf, ID mpfid)
+{
+	ER result;
+
+	if(ISVALID_MPFID(mpfid))
+	{
+		if(ISVALID_PTR(pk_rmpf))
+		{
+			T_MPFCB *p_mpfcb;
+
+			p_mpfcb = &(mpfcbs[mpfid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 != p_mpfcb->mpfid)
+			{
+				pk_rmpf->exinf = p_mpfcb->exinf;
+				pk_rmpf->wtsk = TSK_GET_WTSKID(&(p_mpfcb->wtsklst));
+				pk_rmpf->frbcnt = p_mpfcb->frbcnt;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/mpf.h
@@ -0,0 +1,9 @@
+#ifndef _MPF_H_
+#define _MPF_H_
+
+#include <itron.h>
+
+ER mpf_initialize(void);
+void mpf_terminate(void);
+
+#endif /* _MPF_H_ */

--- /dev/null
+++ b/src/mpl.c
@@ -0,0 +1,232 @@
+#include "mpl.h"
+#include "it3_common.h"
+#include "it3_config.h"
+
+#define	ISVALID_MPLID(mplid)		((0 < (mplid)) && ((mplid) < TNUM_MPL))
+#define	ISVALID_MPLATR(mplatr)		(TRUE)	/* 属性情報はチェックしない */
+
+typedef struct S_MPLCB
+{
+	ID						mplid;
+
+	VP						exinf;			/* 拡張情報						*/
+	ATR						mplatr;			/* メモリプール属性				*/
+	INT						mplsz;			/* メモリプール全体のサイズ		*/
+
+} T_MPLCB;
+
+static const T_MPLCB mplcb_initializer = {0};
+
+static T_MPLCB mplcbs[TNUM_MPL];
+
+ER mpl_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_MPL;cnt++)
+	{
+		mplcbs[cnt] = mplcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void mpl_terminate(void)
+{
+
+}
+
+ER cre_mpl(ID mplid, T_CMPL *pk_cmpl)
+{
+	ER result;
+
+	if(ISVALID_MPLID(mplid))
+	{
+		if(ISVALID_PTR(pk_cmpl) && ISVALID_MPLATR(pk_cmpl->mplatr))
+		{
+			T_MPLCB *p_mplcb;
+
+			p_mplcb = &(mplcbs[mplid]);
+
+			if(0 == p_mplcb->mplid)
+			{
+				*p_mplcb = mplcb_initializer;
+
+				p_mplcb->mplid = mplid;
+
+				p_mplcb->exinf = pk_cmpl->exinf;
+				p_mplcb->mplatr = pk_cmpl->mplatr;
+				p_mplcb->mplsz = pk_cmpl->mplsz;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER del_mpl(ID mplid)
+{
+	ER result;
+
+	if(ISVALID_MPLID(mplid))
+	{
+		T_MPLCB *p_mplcb;
+
+		p_mplcb = &(mplcbs[mplid]);
+
+		if(0 != p_mplcb->mplid)
+		{
+			*p_mplcb = mplcb_initializer;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER get_blk(VP *p_blk, ID mplid, INT blksz)
+{
+	return tget_blk(p_blk, mplid, blksz, TMO_FEVR);
+}
+
+ER pget_blk(VP *p_blk, ID mplid, INT blksz)
+{
+	return tget_blk(p_blk, mplid, blksz, TMO_POL);
+}
+
+ER ipget_blk(VP *p_blk, ID mplid, INT blksz)
+{
+	return E_NOSPT;
+}
+
+ER tget_blk(VP *p_blk, ID mplid, INT blksz, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_MPLID(mplid))
+	{
+		if(ISVALID_PTR(p_blk) && (0 < blksz) && ISVALID_TMOUT(tmout))
+		{
+			T_MPLCB *p_mplcb;
+
+			p_mplcb = &(mplcbs[mplid]);
+
+			if(0 != p_mplcb->mplid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER rel_blk(ID mplid, VP blk)
+{
+	ER result;
+
+	if(ISVALID_MPLID(mplid))
+	{
+		if(ISVALID_PTR(blk))
+		{
+			T_MPLCB *p_mplcb;
+
+			p_mplcb = &(mplcbs[mplid]);
+
+			if(0 != p_mplcb->mplid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER ref_mpl(T_RMPL *pk_rmpl, ID mplid)
+{
+	ER result;
+
+	if(ISVALID_MPLID(mplid))
+	{
+		if(ISVALID_PTR(pk_rmpl))
+		{
+			T_MPLCB *p_mplcb;
+
+			p_mplcb = &(mplcbs[mplid]);
+
+			if(0 != p_mplcb->mplid)
+			{
+				pk_rmpl->exinf = p_mplcb->exinf;
+				pk_rmpl->wtsk = FALSE;		// TODO どうしよっかなー
+				pk_rmpl->frsz = 0;			// TODO どうしよっかなー
+				pk_rmpl->maxsz = 0;			// TODO どうしよっかなー
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/mpl.h
@@ -0,0 +1,9 @@
+#ifndef _MPL_H_
+#define _MPL_H_
+
+#include <itron.h>
+
+ER mpl_initialize(void);
+void mpl_terminate(void);
+
+#endif /* _MPL_H_ */

--- /dev/null
+++ b/src/net.c
@@ -0,0 +1,31 @@
+#include "net.h"
+
+ER net_initialize(void)
+{
+	return E_OK;
+}
+
+void net_terminate(void)
+{
+}
+
+ER nrea_dat(INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr, INT datsz)
+{
+	return E_NOSPT;
+}
+
+ER nwri_dat(INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr, INT datsz)
+{
+	return E_NOSPT;
+}
+
+ER nget_nod(NODE *p_node)
+{
+	return E_NOSPT;
+}
+
+ER nget_ver(T_VER *pk_ver, NODE node)
+{
+	return E_NOSPT;
+}
+

--- /dev/null
+++ b/src/net.h
@@ -0,0 +1,9 @@
+#ifndef _NET_H_
+#define _NET_H_
+
+#include <itron.h>
+
+ER net_initialize(void);
+void net_terminate(void);
+
+#endif /* _NET_H_ */

--- /dev/null
+++ b/src/por.c
@@ -0,0 +1,307 @@
+#include "por.h"
+#include "it3_common.h"
+#include "it3_config.h"
+
+#include "lst.h"
+
+#define	ISVALID_PORID(porid)	((0 < (porid)) && ((porid) < TNUM_POR))
+#define	ISVALID_PORATR(poratr)	(TRUE)	/* 属性情報はチェックしない */
+#define	ISVALID_RDVNO(rdvno)	(TRUE)	/* TODO RNOの判定はどうやるんだ? */
+
+typedef struct S_PORCB
+{
+	T_LST		call_queue;		/* ポート呼出待ちキュー */
+	ID			porid;			/* ポートID */
+	VP			exinf;			/* 拡張情報 */
+	ATR			poratr;			/* ポート属性 */
+	T_LST		accept_queue;	/* ポート受付待ちキュー */
+	INT			maxcmsz;		/* 呼出メッセージの最大長 */
+	INT			maxrmsz;		/* 返答メッセージの最大長 */
+} T_PORCB;
+
+static T_PORCB porcbs[TNUM_POR];
+
+static const T_PORCB porcb_initializer = {0};
+
+ER por_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_POR;cnt++)
+	{
+		porcbs[cnt] = porcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void por_terminate(void)
+{
+
+}
+
+/* ランデブ用のポート生成 */
+ER cre_por(ID porid, T_CPOR *pk_cpor)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		if(ISVALID_PTR(pk_cpor))
+		{
+			T_PORCB *p_porcb;
+
+			p_porcb = &(porcbs[porid]);
+
+			if(0 == p_porcb->porid)
+			{
+				*p_porcb = porcb_initializer;
+
+				p_porcb->porid = porid;
+
+				p_porcb->exinf = pk_cpor->exinf;
+				p_porcb->poratr = pk_cpor->poratr;
+				p_porcb->maxcmsz = pk_cpor->maxcmsz;
+				p_porcb->maxrmsz = pk_cpor->maxrmsz;
+
+				lst_init(&(p_porcb->accept_queue));
+				lst_init(&(p_porcb->call_queue));
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* ランデブ用のポート削除 */
+ER del_por(ID porid)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		T_PORCB *p_porcb;
+
+		p_porcb = &(porcbs[porid]);
+
+		if(0 != p_porcb->porid)
+		{
+			*p_porcb = porcb_initializer;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* ポートに対するランデブの呼出 */
+ER cal_por(VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT cmsgsz)
+{
+	return tcal_por(msg, p_rmsgsz, porid, calptn, cmsgsz, TMO_FEVR);
+}
+
+/* ポートに対するランデブの呼出(ポーリング) */
+ER pcal_por(VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT cmsgsz)
+{
+	return tcal_por(msg, p_rmsgsz, porid, calptn, cmsgsz, TMO_POL);
+}
+
+/* ポートに対するランデブの呼出(タイムアウト有) */
+ER tcal_por(VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT cmsgsz, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		if(ISVALID_PTR(msg) && ISVALID_PTR(p_rmsgsz) && (0 != calptn) && (0 < cmsgsz) && ISVALID_TMOUT(tmout))
+		{
+			T_PORCB *p_porcb;
+
+			p_porcb = &(porcbs[porid]);
+
+			if(0 != p_porcb->porid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* ポートに対するランデブ受付 */
+ER acp_por(RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT acpptn)
+{
+	return tacp_por(p_rdvno, msg, p_cmsgsz, porid, acpptn, TMO_FEVR);
+}
+
+/* ポートに対するランデブ受付(ポーリング) */
+ER pacp_por(RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT acpptn)
+{
+	return tacp_por(p_rdvno, msg, p_cmsgsz, porid, acpptn, TMO_POL);
+}
+
+/* ポートに対するランデブ受付(タイムアウト有) */
+ER tacp_por(RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT acpptn, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		if(ISVALID_PTR(p_rdvno) && ISVALID_PTR(msg) && ISVALID_PTR(p_cmsgsz) && (0 != acpptn) && ISVALID_TMOUT(tmout))
+		{
+			T_PORCB *p_porcb;
+
+			p_porcb = &(porcbs[porid]);
+
+			if(0 != p_porcb->porid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* ポートに対するランデブ回送 */
+ER fwd_por(ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		if((0 != calptn) && ISVALID_RDVNO(rdvno) && ISVALID_PTR(msg) && (0 < cmsgsz))
+		{
+			T_PORCB *p_porcb;
+
+			p_porcb = &(porcbs[porid]);
+
+			if(0 != p_porcb->porid)
+			{
+				// TODO どうしよっかなー
+				result = E_NOSPT;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* ランデブ返答 */
+ER rpl_rdv(RNO rdvno, VP msg, INT rmsgsz)
+{
+	ER result;
+
+	if(ISVALID_RDVNO(rdvno) && ISVALID_PTR(msg) && (0 < rmsgsz))
+	{
+		// TODO どうしよっかなー
+		result = E_NOSPT;
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/* ポート状態参照 */
+ER ref_por(T_RPOR *pk_rpor, ID porid)
+{
+	ER result;
+
+	if(ISVALID_PORID(porid))
+	{
+		if(ISVALID_PTR(pk_rpor))
+		{
+			T_PORCB *p_porcb;
+
+			p_porcb = &(porcbs[porid]);
+
+			if(0 != p_porcb->porid)
+			{
+				pk_rpor->exinf = p_porcb->exinf;
+				pk_rpor->wtsk = FALSE;		// TODO どうしよっかなー
+				pk_rpor->atsk = FALSE;		// TODO どうしよっかなー
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/por.h
@@ -0,0 +1,9 @@
+#ifndef _POR_H_
+#define _POR_H_
+
+#include <itron.h>
+
+ER por_initialize(void);
+void por_terminate(void);
+
+#endif /* _POR_H_ */

--- /dev/null
+++ b/src/que_ctl.c
@@ -0,0 +1,680 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "kernel.h"
+
+#include "tsk.h"
+
+extern T_LST rdq[];
+
+/* レディキューにタスクを追加 */
+ER add_rdq(T_TCB *p_tcb)
+{
+	lst_insert(&(rdq[p_tcb->tskpri]), (T_LST *)p_tcb);
+
+	return E_OK;
+}
+
+/* レディキューからタスクを削除 */
+void del_rdq(T_TCB *p_tcb)
+{
+	lst_delete((T_LST *)p_tcb);
+}
+
+#if 0 // move to flg.c
+/*--------------------------------------------------------------------------*/
+/*                 イベントフラグ待ちキューにタスクを追加                   */
+/*--------------------------------------------------------------------------*/
+void add_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb)
+{
+
+	if(TA_TPRI & p_flgcb->flgatr)
+	{
+		T_LST *p_insert_pos;
+
+		p_insert_pos = p_flgcb->wtsklst.p_next;
+
+		while(&(p_flgcb->wtsklst) != p_insert_pos)
+		{
+			if(p_tcb->tskpri < ((T_TCB *)p_insert_pos)->tskpri)
+			{
+				break;
+			}
+
+			p_insert_pos = p_insert_pos->p_next;
+		}
+
+		lst_insert(p_insert_pos, (T_LST *)p_tcb);
+	}
+	else
+	{
+		lst_insert(&(p_flgcb->wtsklst), (T_LST *)p_tcb);
+	}
+
+#if 0 // T_LSTへ移行するので使うのやめる
+	T_FLGCB *p_flgq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_flgq = &flgq[addtcb->wid];
+
+	toptcb = p_flgq->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		if( p_flgq->wtskmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			addtcb->prev = endtcb;
+			addtcb->next = toptcb;
+			toptcb->prev = addtcb;
+			endtcb->next = addtcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( addtcb->pri < nextcb->pri )
+				{
+					pretcb = nextcb->prev;
+
+					addtcb->prev = pretcb;
+					addtcb->next = nextcb;
+					nextcb->prev = addtcb;
+					pretcb->next = addtcb;
+
+					if( nextcb == toptcb )
+					{
+						p_flgq->head = addtcb;
+					}
+
+					break;
+				}
+
+				nextcb = nextcb->next;
+			} while((nextcb != toptcb) && (p_flgq->head != NULL));
+
+			if( nextcb == toptcb )
+			{
+				addtcb->prev = endtcb;
+				addtcb->next = toptcb;
+				toptcb->prev = addtcb;
+				endtcb->next = addtcb;
+			}
+		}
+
+		(p_flgq->wtskcnt)++;				/* 待ちタスク数を加算 */
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_flgq->head   = addtcb;
+		addtcb->next = addtcb;
+		addtcb->prev = addtcb;
+
+		p_flgq->wtskcnt = 1;					/* 待ちタスク数は１ */
+	}
+
+	return;
+#endif
+}
+
+/*--------------------------------------------------------------------------*/
+/*                イベントフラグ待ちキューからタスクを削除                  */
+/*--------------------------------------------------------------------------*/
+void del_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb)
+{
+	lst_delete((T_LST *)p_tcb);
+
+#if 0 // T_LSTへ移行するので使うのやめる
+	T_FLGCB	*p_flgq;
+	T_TCB	*pretcb, *nextcb;
+
+	p_flgq = &flgq[deltcb->wid];
+
+	if( (pretcb = deltcb->prev) != deltcb )
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+		if( p_flgq->head == deltcb )
+		{
+			p_flgq->head = nextcb;
+		}
+
+		( p_flgq->wtskcnt )--;		/* 待ちタスク数を減算 */
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_flgq->head = NULL;
+
+		p_flgq->wtskcnt = 0;			/* 待ちタスク数は０ */
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+#endif
+}
+#endif
+
+#if 0 // move to sem.c
+/*--------------------------------------------------------------------------*/
+/*                    セマフォ待ちキューにタスクを追加                      */
+/*--------------------------------------------------------------------------*/
+void add_semq( T_TCB *addtcb )
+{
+	T_SEMCB *p_semq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_semq = &(semq[addtcb->wid]);
+
+	toptcb = semq->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+
+		if( semq->wtskmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			addtcb->prev = endtcb;
+			addtcb->next = toptcb;
+			toptcb->prev = addtcb;
+			endtcb->next = addtcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( addtcb->pri < nextcb->pri )
+				{
+
+					pretcb = nextcb->prev;
+
+					addtcb->prev = pretcb;
+					addtcb->next = nextcb;
+					nextcb->prev = addtcb;
+					pretcb->next = addtcb;
+
+					if( nextcb == toptcb )
+					{
+						p_semq->head = addtcb;
+					}
+					break;
+				}
+
+				nextcb = nextcb->next;
+
+			} while((nextcb != toptcb) && (p_semq->head != NULL));
+
+			if(nextcb == toptcb)
+			{
+				addtcb->prev = endtcb;
+				addtcb->next = toptcb;
+				toptcb->prev = addtcb;
+				endtcb->next = addtcb;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_semq->head = addtcb;
+		addtcb->next = addtcb;
+		addtcb->prev = addtcb;
+	}
+
+	return;
+}
+
+/*--------------------------------------------------------------------------*/
+/*                   セマフォ待ちキューからタスクを削除                     */
+/*--------------------------------------------------------------------------*/
+void del_semq( T_TCB *deltcb )
+{
+	T_SEMCB *p_semq;
+	T_TCB *pretcb, *nextcb;
+
+	p_semq = &(semq[deltcb->wid]);
+
+	pretcb = deltcb->prev;
+	if(pretcb != deltcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+
+		if( p_semq->head == deltcb )
+		{
+			p_semq->head = nextcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		semq->head = NULL;
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+}
+#endif
+#if 0 // move to msg.c
+/*--------------------------------------------------------------------------*/
+/*                   メッセージ待ちキューにタスクを追加                     */
+/*--------------------------------------------------------------------------*/
+void add_mbxq(T_TCB *addtcb)
+{
+	T_MBXCB *p_mbxq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_mbxq = &(mbxq[addtcb->wid]);
+
+	toptcb = p_mbxq->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		if(p_mbxq->wtskmode == TA_TFIFO)	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			addtcb->prev = endtcb;
+			addtcb->next = toptcb;
+			toptcb->prev = addtcb;
+			endtcb->next = addtcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( addtcb->pri < nextcb->pri )
+				{
+					pretcb = nextcb->prev;
+
+					addtcb->prev = pretcb;
+					addtcb->next = nextcb;
+					nextcb->prev = addtcb;
+					pretcb->next = addtcb;
+
+					if( nextcb == toptcb )
+					{
+						p_mbxq->head = addtcb;
+					}
+					break;
+				}
+
+				nextcb = nextcb->next;
+
+			} while( (nextcb != toptcb)&&(mbxq->head != NULL) );
+
+			if( nextcb == toptcb )
+			{
+				addtcb->prev = endtcb;
+				addtcb->next = toptcb;
+				toptcb->prev = addtcb;
+				endtcb->next = addtcb;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		mbxq->head   = addtcb;
+		addtcb->next = addtcb;
+		addtcb->prev = addtcb;
+	}
+
+	return;
+}
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージ待ちキューからタスクを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_mbxq(T_TCB *deltcb)
+{
+	T_MBXCB *p_mbxq;
+	T_TCB *pretcb, *nextcb;
+
+	p_mbxq = &(mbxq[deltcb->wid]);
+
+	pretcb = deltcb->prev;
+	if(pretcb != deltcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+		if(p_mbxq->head == deltcb)
+		{
+			mbxq->head = nextcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		mbxq->head = NULL;
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+}
+#endif
+#if 0 // move to msg.c
+/*--------------------------------------------------------------------------*/
+/*                   メッセージキューにメッセージを追加                     */
+/*--------------------------------------------------------------------------*/
+void add_msg(ID mbxid, T_MSG *addmsg)
+{
+	T_MBXCB *p_mbxq;
+	T_MSG *topmsg, *endmsg, *nexmsg, *premsg;
+
+	p_mbxq = &(mbxq[mbxid]);
+
+	topmsg = mbxq->msg;
+	if(topmsg != NULL)
+	{
+		/*-------------------- 他のメッセージがある --------------------*/
+		if( mbxq->wmsgmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endmsg       = topmsg->pk_prev;
+			addmsg->pk_prev = endmsg;
+			addmsg->pk_next = topmsg;
+			topmsg->pk_prev = addmsg;
+			endmsg->pk_next = addmsg;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endmsg = topmsg->pk_prev;
+			nexmsg = topmsg;
+
+			do
+			{
+				if( tcb[addmsg->tskid].pri < tcb[nexmsg->tskid].pri )
+				{
+					premsg = nexmsg->pk_prev;
+
+					addmsg->pk_prev = premsg;
+					addmsg->pk_next = nexmsg;
+					nexmsg->pk_prev = addmsg;
+					premsg->pk_next = addmsg;
+
+					if( nexmsg == topmsg )
+					{
+						mbxq->msg = addmsg;
+					}
+
+					break;
+				}
+
+				nexmsg = nexmsg->pk_next;
+
+			} while( (nexmsg != topmsg)&&(mbxq->msg != NULL) );
+
+			if( nexmsg == topmsg )
+			{
+				addmsg->pk_prev = endmsg;
+				addmsg->pk_next = topmsg;
+				topmsg->pk_prev = addmsg;
+				endmsg->pk_next = addmsg;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のメッセージがない --------------------*/
+		mbxq->msg    = addmsg;
+		addmsg->pk_next = addmsg;
+		addmsg->pk_prev = addmsg;
+	}
+
+	return;
+}
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージキューからメッセージを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_msg(ID mbxid, T_MSG *delmsg)
+{
+	T_MBXCB *p_mbxq;
+	T_MSG *premsg, *nexmsg;
+
+	p_mbxq = &(mbxq[mbxid]);
+
+	premsg = delmsg->pk_prev;
+	if(premsg != delmsg )
+	{
+		/*-------------------- 他のメッセージがある --------------------*/
+		nexmsg       = delmsg->pk_next;
+		premsg->pk_next = nexmsg;
+		nexmsg->pk_prev = premsg;
+
+		if(p_mbxq->msg == delmsg)
+		{
+			mbxq->msg = nexmsg;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のメッセージがない --------------------*/
+		p_mbxq->msg = NULL;
+	}
+
+	delmsg->pk_next  = NULL;
+	delmsg->pk_prev  = NULL;
+
+	return;
+}
+#endif
+
+/*--------------------------------------------------------------------------*/
+/*                     タイマ待ちキューにタスクを追加                       */
+/*--------------------------------------------------------------------------*/
+void add_timq(T_TCB *addtcb)
+{
+	T_TIMQ *p_timq;
+	T_TCB *toptcb, *endtcb, *pretcb, *nextcb;
+
+	p_timq = &(timq);
+
+	toptcb = p_timq->head;
+	/*-------------------- 他のタスクがある --------------------*/
+	if(toptcb != NULL )
+	{
+		endtcb = toptcb->prev;
+		nextcb = toptcb;
+
+		do
+		{
+			if(addtcb->tmout < nextcb->tmout)
+			{
+				pretcb = nextcb->prev;
+
+				addtcb->prev = pretcb;
+				addtcb->next = nextcb;
+				nextcb->prev = addtcb;
+				pretcb->next = addtcb;
+
+				if(nextcb == toptcb)
+				{
+					p_timq->head = addtcb;
+				}
+
+				break;
+			}
+
+			nextcb = nextcb->next;
+
+		} while( (nextcb != toptcb)&&(p_timq->head != NULL) );
+
+		if( nextcb == toptcb )
+		{
+			addtcb->prev = endtcb;
+			addtcb->next = toptcb;
+			toptcb->prev = addtcb;
+			endtcb->next = addtcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_timq->head   = addtcb;
+		addtcb->next = addtcb;
+		addtcb->prev = addtcb;
+	}
+
+	return;
+}
+
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージ待ちキューからタスクを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_timq(T_TCB *deltcb)
+{
+	T_TIMQ *p_timq;
+	T_TCB *pretcb, *nextcb;
+
+	p_timq = &timq;
+
+	pretcb = deltcb->prev;
+	if(pretcb != deltcb )
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = deltcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+
+		if( p_timq->head == deltcb )
+		{
+			p_timq->head = nextcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_timq->head = NULL;
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+}
+
+#if 0
+/*--------------------------------------------------------------------------*/
+/*                           ディスパッチ要求記憶                           */
+/*--------------------------------------------------------------------------*/
+ER		dispatch( errcode )
+REG ER		errcode;
+{
+		DISPATCH = ON;
+		return( errcode );
+}
+/*--------------------------------------------------------------------------*/
+/*                         次に実行するタスクを検索                         */
+/*--------------------------------------------------------------------------*/
+//#include "irqdef.h"
+UH		next_tsk()
+{
+	T_RDQ	*rdq;
+
+	if( DISPATCH == OFF )	return( OFF );	/* ディスパッチ要求なし */
+	if( DSPENA == OFF )		return( OFF );	/* ディスパッチ禁止状態	*/
+
+	rdq = &RDQ[ 0 ];
+
+	while(1){
+		if( rdq->head != NULL )	break;
+		rdq++;
+	}
+	DISPATCH = OFF;
+
+	if( rdq->head == NOW_TCB )	return( OFF );	/* スイッチング必要なし */
+
+	NEXT_TCB = rdq->head;			/* 次実行タスクの TCB アドレス */
+	return( ON );
+}
+#endif
+
+/*--------------------------------------------------------------------------*/
+/*                      論理タイマ処理（10msに１回起動）                    */
+/*--------------------------------------------------------------------------*/
+void os_timer(void)
+{
+	T_TCB *p_tcb;
+	T_TIMQ *p_timq;
+
+//	os_cyc(1);
+//	os_alm(1);
+
+	p_timq = &timq;
+
+	(p_timq->time)++;		/* タイマをカウントアップ（10ms単位） */
+
+	p_tcb = p_timq->head;
+
+	while(NULL != p_tcb)	/* タイマ待ちのタスクがある */
+	{
+		if(p_tcb->tmout <= p_timq->time)			/* タイムアウト時間 */
+		{
+			del_timq(p_tcb);					/* TIMQ から TCB を外す */
+
+			if(TTW_FLG & p_tcb->tskwait)	/* イベントフラグ待ち */
+			{
+				T_TCBTMO *tcbtmo = (T_TCBTMO *)p_tcb;	/* tricky! */
+				p_tcb = tcbtmo->tcb;	/* TCB の本体 */
+
+				tcbtmo->sts = 0;
+
+// TODO				del_flgq(p_tcb);		/* FLGQ から TCB を外す */
+
+//				((T_TSKCTX *)p_tcb->sp)->r0 = E_TMOUT;
+				/* エラーコードをポーリング失敗またはタイムアウトに */
+			}
+
+			if(p_tcb->tskstat & TTS_SUS )
+			{
+				/* 二重待ち状態 */
+				p_tcb->tskstat = TTS_SUS;		/* タスク状態を SUSPEND に */
+			}
+			else
+			{
+				/* 時間待ち状態 */
+// TODO				add_rdq(p_tcb);					/* RDQ に TCB をつなげる */
+				p_tcb->tskstat = TTS_RDY;			/* タスク状態を READY に */
+			}
+
+//			DISPATCH = ON;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	return;
+}

--- /dev/null
+++ b/src/que_ctl.h
@@ -0,0 +1,111 @@
+#ifndef que_ctl_h_Included
+#define que_ctl_h_Included
+
+#include <itron.h>
+#include "tsk.h"
+
+/*--------------------------------------------------------------------------*/
+/*                        レディキューにタスクを追加                        */
+/*--------------------------------------------------------------------------*/
+ER add_rdq( T_TCB *addtcb );
+
+/*--------------------------------------------------------------------------*/
+/*                        レディキューからタスクを削除                      */
+/*--------------------------------------------------------------------------*/
+void del_rdq( T_TCB *deltcb );
+
+#if 0 // move to flg.c
+/*--------------------------------------------------------------------------*/
+/*                 イベントフラグ待ちキューにタスクを追加                   */
+/*--------------------------------------------------------------------------*/
+void add_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb);
+
+/*--------------------------------------------------------------------------*/
+/*                イベントフラグ待ちキューからタスクを削除                  */
+/*--------------------------------------------------------------------------*/
+void del_flgq(T_FLGCB *p_flgcb, T_TCB *p_tcb);
+#endif
+#if 0 // move to sem.c
+/*--------------------------------------------------------------------------*/
+/*                    セマフォ待ちキューにタスクを追加                      */
+/*--------------------------------------------------------------------------*/
+void add_semq( T_TCB *addtcb );
+
+/*--------------------------------------------------------------------------*/
+/*                   セマフォ待ちキューからタスクを削除                     */
+/*--------------------------------------------------------------------------*/
+void del_semq( T_TCB *deltcb );
+#endif
+#if 0 // move to msg.c
+/*--------------------------------------------------------------------------*/
+/*                   メッセージ待ちキューにタスクを追加                     */
+/*--------------------------------------------------------------------------*/
+void add_mbxq( T_TCB *addtcb );
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージ待ちキューからタスクを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_mbxq( T_TCB *deltcb );
+
+/*--------------------------------------------------------------------------*/
+/*                   メッセージキューにメッセージを追加                     */
+/*--------------------------------------------------------------------------*/
+void add_msg( ID mbxid, T_MSG *addmsg );
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージキューからメッセージを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_msg( ID mbxid, T_MSG *delmsg );
+#endif
+/*--------------------------------------------------------------------------*/
+/*                     タイマ待ちキューにタスクを追加                       */
+/*--------------------------------------------------------------------------*/
+void add_timq( T_TCB *addtcb );
+
+/*--------------------------------------------------------------------------*/
+/*                  メッセージ待ちキューからタスクを削除                    */
+/*--------------------------------------------------------------------------*/
+void del_timq( T_TCB *deltcb );
+
+#if 0
+/*--------------------------------------------------------------------------*/
+/*                           ディスパッチ要求記憶                           */
+/*--------------------------------------------------------------------------*/
+ER		dispatch( errcode )
+REG ER		errcode;
+{
+		DISPATCH = ON;
+		return( errcode );
+}
+/*--------------------------------------------------------------------------*/
+/*                         次に実行するタスクを検索                         */
+/*--------------------------------------------------------------------------*/
+//#include "irqdef.h"
+UH		next_tsk()
+{
+	T_RDQ	*rdq;
+
+	if( DISPATCH == OFF )	return( OFF );	/* ディスパッチ要求なし */
+	if( DSPENA == OFF )		return( OFF );	/* ディスパッチ禁止状態	*/
+
+	rdq = &RDQ[ 0 ];
+
+	while(1){
+		if( rdq->head != NULL )	break;
+		rdq++;
+	}
+	DISPATCH = OFF;
+
+	if( rdq->head == NOW_TCB )	return( OFF );	/* スイッチング必要なし */
+
+	NEXT_TCB = rdq->head;			/* 次実行タスクの TCB アドレス */
+	return( ON );
+}
+#endif
+
+/*--------------------------------------------------------------------------*/
+/*                      論理タイマ処理（10msに１回起動）                    */
+/*--------------------------------------------------------------------------*/
+void os_timer(void);
+
+#endif /* que_ctl_h_Included */

--- /dev/null
+++ b/src/sem.c
@@ -0,0 +1,912 @@
+/**
+ * @brief	同期・通信機能（セマフォ）
+ *
+ * @author	nikarana
+ * @date	2012/11/23
+ */
+
+#include "sem.h"
+#include "it3_debug.h"
+#include "it3_common.h"
+#include "lst.h"
+
+#include "kernel.h"
+
+#include "que_ctl.h"
+
+#define	ISVALID_SEMID(semid)	((0 < (semid)) && ((semid) < TNUM_SEM))
+#define	ISVALID_SEMCNT(semcnt, maxsem)	((0 < (semcnt)) && ((semcnt) < (maxsem)))
+#define	ISVALID_SEMATR(sematr)	(TRUE)		/* 属性情報はチェックしない */
+
+/* セマフォ管理ブロック(SEMCB) */
+typedef struct S_SEMCB
+{
+	ID			semid;							/**< セマフォID					*/
+
+	VP			exinf;							/**< 拡張情報					*/
+	ATR			sematr;							/**< セマフォ属性				*/
+	INT			maxsem;							/**< セマフォの最大値				*/
+
+	INT			semcnt;							/**< セマフォカウンタ				*/
+	T_LST		wtsklst;						/**< 待ちタスクリスト				*/
+
+
+	T_TCB		*head;							/**< 先頭TCBへのポインタ			*/
+	VH			wtskmode;						/**< 待ち順序					*/
+	ID			tskid;							/**< セマを持っているタスク		*/
+	VB			dmy[6];							/**< ダミー						*/
+} T_SEMCB;
+
+static const T_SEMCB semcb_initializer = {0};
+
+static T_SEMCB semcbs[TNUM_SEM];
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif	/* defined(__cplusplus) */
+
+static void CreateCriticalSection(void)
+{
+
+}
+
+static void EnterCriticalSection(void)
+{
+
+}
+
+static void LeaveCriticalSection(void)
+{
+
+}
+
+/* セマフォ待ちキューにタスクを追加 */
+static void add_semq(T_SEMCB *p_semcb, T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_semcb);
+	IT3_ASSERT(p_tcb);
+
+	if(TA_TPRI & p_semcb->sematr)
+	{
+		T_LST *p_insert_pos;
+
+		p_insert_pos = p_semcb->wtsklst.p_next;
+
+		while(&(p_semcb->wtsklst) != p_insert_pos)
+		{
+			if(p_tcb->tskpri < ((T_TCB *)p_insert_pos)->tskpri)
+			{
+				break;
+			}
+
+			p_insert_pos = p_insert_pos->p_next;
+		}
+
+		lst_insert(p_insert_pos, (T_LST *)p_tcb);
+	}
+	else
+	{
+		lst_insert(&(p_semcb->wtsklst), (T_LST *)p_tcb);
+	}
+
+
+#if 0
+	T_SEMCB *p_semq;
+	T_TCB *toptcb, *endtcb, *nextcb, *pretcb;
+
+	p_semq = &(semcbs[p_tcb->wid]);
+
+	toptcb = semcbs->head;
+	if(NULL != toptcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+
+		if( semcbs->wtskmode == TA_TFIFO )	/* 待ち順序は FIFO */
+		{
+			/* 一番後ろにつなげる */
+			endtcb       = toptcb->prev;
+			p_tcb->prev = endtcb;
+			p_tcb->next = toptcb;
+			toptcb->prev = p_tcb;
+			endtcb->next = p_tcb;
+		}
+		else								/* 待ち順序は 優先順 */
+		{
+			/* 挿入場所を探してつなげる */
+			endtcb = toptcb->prev;
+			nextcb = toptcb;
+
+			do
+			{
+				if( p_tcb->pri < nextcb->pri )
+				{
+
+					pretcb = nextcb->prev;
+
+					p_tcb->prev = pretcb;
+					p_tcb->next = nextcb;
+					nextcb->prev = p_tcb;
+					pretcb->next = p_tcb;
+
+					if( nextcb == toptcb )
+					{
+						p_semq->head = p_tcb;
+					}
+					break;
+				}
+
+				nextcb = nextcb->next;
+
+			} while((nextcb != toptcb) && (p_semq->head != NULL));
+
+			if(nextcb == toptcb)
+			{
+				p_tcb->prev = endtcb;
+				p_tcb->next = toptcb;
+				toptcb->prev = p_tcb;
+				endtcb->next = p_tcb;
+			}
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		p_semq->head = p_tcb;
+		p_tcb->next = p_tcb;
+		p_tcb->prev = p_tcb;
+	}
+
+	return;
+#endif
+}
+
+/* セマフォ待ちキューからタスクを削除 */
+static void del_semq(T_SEMCB *p_semcb, T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_tcb);
+
+	lst_delete((T_LST *)p_tcb);
+
+#if 0
+	T_SEMCB *p_semq;
+	T_TCB *pretcb, *nextcb;
+
+	p_semq = &(semcbs[p_tcb->wid]);
+
+	pretcb = p_tcb->prev;
+	if(pretcb != p_tcb)
+	{
+		/*-------------------- 他のタスクがある --------------------*/
+		nextcb       = p_tcb->next;
+		pretcb->next = nextcb;
+		nextcb->prev = pretcb;
+
+		if( p_semq->head == p_tcb )
+		{
+			p_semq->head = nextcb;
+		}
+	}
+	else
+	{
+		/*-------------------- 他のタスクがない --------------------*/
+		semcbs->head = NULL;
+	}
+
+	/*deltcb->prev = NULL;*/
+	/*deltcb->next = NULL;*/
+
+	return;
+#endif
+}
+
+ER sem_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_SEM;cnt++)
+	{
+		semcbs[cnt] = semcb_initializer;
+	}
+
+	return E_OK;
+}
+
+void sem_terminate(void)
+{
+}
+
+/**
+ * @brief	セマフォ生成
+ *
+ * @param	semid	セマフォID
+ * @param	pk_csem	セマフォ生成情報
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_NOMEM	メモリ不足(管理ブロック用の領域が確保できない)
+ * @retval	E_ID	不正ID番号(semidが不正あるいは利用できない)
+ * @retval	E_RSATR	予約属性(sematrが不正あるいは利用できない)
+ * @retval	E_OBJ	オブジェクトの状態が不正(同一ID番号のセマフォが既に存在)
+ * @retval	E_OACV	オブジェクトアクセス権違反(ユーザタスクからの発行でsemid<(-4), インプリメント依存)
+ * @retval	E_PAR	パラメータエラー(pk_csemが不正, isemcnt, maxsemが負または不正)
+ * @retval	EN_OBJNO	対象ノード側でアクセスできないオブジェクト番号を指定
+ * @retval	EN_CTXID	タスク独立部あるいはディスパッチ禁止状態のタスクから発行されたシステムコールで他ノード上のオブジェクトを指定
+ */
+ER cre_sem(ID semid, T_CSEM *pk_csem)
+{
+	ER result;
+
+	if(ISVALID_SEMID(semid))
+	{
+		if(ISVALID_PTR(pk_csem) && ISVALID_SEMCNT(pk_csem->isemcnt, pk_csem->maxsem))
+		{
+			if(ISVALID_SEMATR(pk_csem->sematr))
+			{
+				T_SEMCB *p_semcb;
+
+				p_semcb = &(semcbs[semid]);
+
+				if(0 == p_semcb->semid)
+				{
+					*p_semcb = semcb_initializer;
+
+					p_semcb->semid = semid;
+
+					p_semcb->exinf = pk_csem->exinf;
+					p_semcb->sematr = pk_csem->sematr;
+					p_semcb->maxsem = pk_csem->maxsem;
+
+					p_semcb->semcnt = pk_csem->isemcnt;
+					lst_init(&(p_semcb->wtsklst));
+
+					p_semcb->head		= NULL;					/* 先頭TCBへのポインタ		*/
+					p_semcb->wtskmode	= pk_csem->sematr;		/* 待ち順序					*/
+					p_semcb->tskid		= 0;					/* セマを持っているタスク	*/
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_OBJ;
+				}
+			}
+			else
+			{
+				result = E_RSATR;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	セマフォ削除
+ *
+ * @param	semid	セマフォID
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_ID	不正ID番号(semidが不正あるいは利用できない)
+ * @retval	E_NOEXS	オブジェクトが存在していない(semidのセマフォが存在しない)
+ * @retval	E_OACV	オブジェクトアクセス権違反(ユーザタスクからの発行でsemid<(-4), インプリメント依存)
+ * @retval	EN_OBJNO	対象ノード側でアクセスできないオブジェクト番号を指定
+ * @retval	EN_CTXID	タスク独立部あるいはディスパッチ禁止状態のタスクから発行されたシステムコールで他ノード上のオブジェクトを指定
+ */
+ER del_sem(ID semid)
+{
+	ER result;
+
+	if(ISVALID_SEMID(semid))
+	{
+		T_SEMCB *p_semcb;
+
+		p_semcb = &(semcbs[semid]);
+
+		if(0 != p_semcb->semid)
+		{
+			T_TCB *p_tcb;
+
+			/*----- 条件成立を待っているタスクの待ち解除 -----*/
+			while(! lst_empty(&(p_semcb->wtsklst)))
+			{
+				p_tcb = (T_TCB *)(p_semcb->wtsklst.p_next);
+
+				del_semq(p_semcb, p_tcb);						/* SEMQ から TCB を外す */
+
+				/* エラーコードを待ちオブジェクトの削除に */
+				*(p_tcb->p_wercd) = E_DLT;
+
+				p_tcb->tskstat &= ~(TTS_WAI);
+				p_tcb->tskwait &= ~(TTW_SEM);
+				if(! (TTS_SUS & p_tcb->tskstat))
+				{
+					p_tcb->tskstat = TTS_RDY;				/* タスク状態を READY に */
+					p_tcb->tskwait = 0;
+					p_tcb->wid = 0;
+					add_rdq(p_tcb);						/* RDQ に TCB をつなげる */
+				}
+			}
+
+			/*----- 初期化 -----*/
+			p_semcb->semcnt		= 1;
+			p_semcb->wtskmode	= TA_TFIFO;
+			p_semcb->tskid		= 0;
+
+			*p_semcb = semcb_initializer;
+
+			/* ディスパッチされるまで待つ */
+			tsk_wait_dispatch();
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	セマフォ資源返却
+ *
+ * @param	semid	セマフォID
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_ID	不正ID番号(semidが不正あるいは利用できない)
+ * @retval	E_NOEXS	オブジェクトが存在していない(semidのセマフォが存在しない)
+ * @retval	E_OACV	オブジェクトアクセス権違反(ユーザタスクからの発行でsemid<(-4), インプリメント依存)
+ * @retval	E_QOVR	キューイングまたはネストのオーバーフロー(キューイング数semcntのオーバーフロー)
+ * @retval	EN_OBJNO	対象ノード側でアクセスできないオブジェクト番号を指定
+ * @retval	EN_CTXID	タスク独立部あるいはディスパッチ禁止状態のタスクから発行されたシステムコールで他ノード上のオブジェクトを指定
+ */
+ER sig_sem(ID semid)
+{
+	ER result;
+
+	result = isig_sem(semid);
+	if(E_OK == result)
+	{
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return result;
+}
+
+/**
+ * @brief	セマフォ資源返却（タスク独立部）
+ *
+ * @param	semid	セマフォID
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_ID	不正ID番号(semidが不正あるいは利用できない)
+ * @retval	E_NOEXS	オブジェクトが存在していない(semidのセマフォが存在しない)
+ * @retval	E_OACV	オブジェクトアクセス権違反(ユーザタスクからの発行でsemid<(-4), インプリメント依存)
+ * @retval	E_QOVR	キューイングまたはネストのオーバーフロー(キューイング数semcntのオーバーフロー)
+ * @retval	EN_OBJNO	対象ノード側でアクセスできないオブジェクト番号を指定
+ * @retval	EN_CTXID	タスク独立部あるいはディスパッチ禁止状態のタスクから発行されたシステムコールで他ノード上のオブジェクトを指定
+ */
+ER isig_sem(ID semid)
+{
+	ER result;
+
+	if(ISVALID_SEMID(semid))
+	{
+		T_SEMCB *p_semcb;
+
+		p_semcb = &(semcbs[semid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_semcb->semid)
+		{
+			if(lst_empty(&(p_semcb->wtsklst)))
+			{
+				if(p_semcb->semcnt < p_semcb->maxsem)
+				{
+					(p_semcb->semcnt)++;
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_QOVR;
+				}
+			}
+			else
+			{
+				tsk_wait_release((T_TCB *)(p_semcb->wtsklst.p_next), E_OK);
+
+				result = E_OK;
+			}
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+
+#if 0
+	ER ercd;
+	T_SEMCB *p_semq;
+	T_TCB *p_tcb;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_SEMID(semid))
+	{
+		/* ID範囲外 */
+		return E_ID;
+	}
+
+	p_semq = &(semcbs[semid]);
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	/* 現在のタスクが既にセマフォを獲得しているなら、	*/
+	/* 何もしないで正常終了する							*/
+	if(p_semq->tskid != p_tcb->tskid)				/* 既にセマフォ獲得済み?	*/
+	{
+		return E_OK;
+	}
+
+	if(NULL == p_semq->head)
+	{
+		/*----------------- セマフォ待ちのタスクがない ------------------*/
+
+		/*if( p_semq->semcnt == 1 ){*/
+			/*printf( "[os] sig_sem(%d)(tskid %d) error semcnt > 1\n",*/
+						/*semid, TSK_SELF );*/
+			/*return( E_OK );*/
+		/*}*/
+
+		(p_semq->semcnt)++;			/* キューイング */
+
+		p_semq->tskid = 0;			/* セマを持っているタスクはない */
+
+		if(p_semq->maxsem < p_semq->semcnt)	/* キューイングのオーバフロー? */
+		{
+			(p_semq->semcnt)--;
+			return E_QOVR;
+		}
+	}
+	else
+	{
+		/*------------------ 待ちタスクに資源を与える -------------------*/
+		p_tcb = p_semq->head;						/* 先頭のセマ待ちタスク  */
+
+		del_semq(p_semq, p_tcb);						/* SEMQ から TCB を外す  */
+
+		if(p_tcb->tskstat & TTS_SUS)
+		{
+			/* 二重待ち状態 */
+			p_tcb->tskstat = TTS_SUS;				/* タスク状態を SUSPEND に	*/
+		}
+		else
+		{
+			p_tcb->tskstat = TTS_RDY;				/* タスク状態を READY に */
+			p_tcb->tskwait = 0;
+			p_tcb->wid = 0;
+
+			/* メッセージ待ち状態 */
+			add_rdq(p_tcb);						/* RDQ に TCB をつなげる */
+		}
+
+		p_semq->tskid = p_tcb->tskid;	/* セマを持っているタスクを記録しておく */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+#endif
+}
+
+/**
+ * @brief	セマフォ資源獲得
+ *
+ * @param	semid	セマフォID
+ * @return	エラーコード
+ * @retval
+ */
+ER wai_sem(ID semid)
+{
+	return twai_sem(semid, TMO_FEVR);
+}
+
+/**
+ * @brief	セマフォ資源獲得(ポーリング)
+ */
+ER preq_sem(ID semid)
+{
+	return twai_sem(semid, TMO_POL);
+}
+
+/**
+ * @brief	セマフォ資源獲得(タイムアウト有)
+ */
+ER twai_sem(ID semid, TMO tmout)
+{
+	ER result;
+
+	if(ISVALID_SEMID(semid))
+	{
+		if(ISVALID_TMOUT(tmout))
+		{
+			T_SEMCB *p_semcb;
+
+			p_semcb = &(semcbs[semid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 < p_semcb->semcnt)						/* 資源がある? */
+			{
+				(p_semcb->semcnt)--;
+
+				result = E_OK;
+			}
+			else
+			{
+				if(TMO_POL != tmout)
+				{
+					ER ret;
+					T_TCB *p_tcb;
+
+					ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+					if(E_OK == ret)
+					{
+						lst_delete((T_LST *)p_tcb);	/* rdqから外す */
+
+						p_tcb->p_wercd = &result;
+						p_tcb->tskstat = TTS_WAI;
+						p_tcb->tskwait = TTW_SEM;
+						p_tcb->wid = semid;		/* セマＩＤを設定                  */
+
+// TODO						tsk_go_wait(p_tcb);
+					}
+					else
+					{
+						result = ret;
+					}
+				}
+				else
+				{
+					result = E_TMOUT;
+				}
+
+#if 0 // 置き換える
+				ER ret;
+				T_TCB *p_tcb;
+
+				ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+				if(E_OK == ret)
+				{
+					del_rdq(p_tcb);			/* RDQ から TCB を外す             */
+
+					p_tcb->tskstat = TTS_WAI;
+					p_tcb->tskwait = TTW_SEM;
+					p_tcb->wid = semid;		/* セマＩＤを設定                  */
+
+					add_semq(p_semcb, p_tcb);		/* SEMQ に TCB をつなぐ            */
+
+					/* ディスパッチされるまで待つ */
+					tsk_wait_dispatch();
+
+					result = E_OK;
+				}
+				else
+				{
+					result = ret;
+				}
+#endif
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+
+#if 0 // 元wai_sem
+	ER ercd;									/* 呼び出した関数の戻り値	*/
+	T_SEMCB *p_semq;
+	T_TCB *p_tcb;
+
+
+//	if( DSPENA == OFF )	{		/* ディスパッチ禁止状態 */
+//		return( E_CTX );
+//	}
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if((semid < 0) || (TNUM_SEM <= semid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_semq = &semcbs[semid];
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	if(0 < p_semq->semcnt)						/* 資源がある? */
+	{
+		(p_semq->semcnt)--;
+		p_semq->tskid = p_tcb->tskid;	/* セマを持っているタスクを記録 */
+
+		return E_OK;
+	}
+	else
+	{
+		/* 資源がないから待ちにする */
+
+		if(p_semq->tskid == p_tcb->tskid )	/* 同じタスクで待とうとしてる? */
+		{
+			/* 既にセマフォを確保しているタスクから */
+			/* 再度セマフォ獲得しようとしているなら、*/
+			/* 待ちとさせない */
+			return E_OK;
+		}
+
+		del_rdq(p_tcb);			/* RDQ から TCB を外す             */
+
+		p_tcb->sts = ((TTW_SEM << 8) | TTS_WAI);	/* タスク状態を WAIT（セマ待ち）に */
+		p_tcb->tskstat = TTS_WAI;
+		p_tcb->tskwait = TTW_SEM;
+		p_tcb->wid = semid;		/* セマＩＤを設定                  */
+
+		add_semq(p_tcb);		/* SEMQ に TCB をつなぐ            */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+#endif
+
+#if 0 /* 元preq_sem */
+
+	ER ercd;
+	T_SEMCB *p_semq;
+	T_TCB *p_tcb;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if(! ISVALID_SEMID(semid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_semq = &(semcbs[semid]);
+
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	if(0 < p_semq->semcnt)						/* 資源がある? */
+	{
+		(p_semq->semcnt)--;
+		p_semq->tskid = p_tcb->tskid;
+	}
+	else
+	{
+		/* 資源がない */
+		return E_TMOUT;
+	}
+
+	return E_OK;
+#endif
+}
+
+/**
+ * @brief	セマフォ状態参照
+ *
+ * @param	pk_rsem	セマフォ状態を返すパケットアドレス
+ * @param	semid	セマフォID
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_ID	不正ID番号(semidが不正あるいは利用できない)
+ * @retval	E_NOEXS	オブジェクトが存在していない(semidのセマフォが存在しない)
+ * @retval	E_OACV	オブジェクトアクセス権違反(ユーザタスクからの発行でsemid<(-4), インプリメント依存)
+ * @retval	E_PAR	パラメータエラー(リターンパラメータ用のパケットアドレスが使用できない値)
+ * @retval	EN_OBJNO	対象ノード側でアクセスできないオブジェクト番号を指定
+ * @retval	EN_CTXID	タスク独立部あるいはディスパッチ禁止状態のタスクから発行されたシステムコールで他ノード上のオブジェクトを指定
+ * @retval	EN_RPAR	要求ノードや通信パケットでサポートされていない範囲の値がリターンパラメータとして返された(exinf, wtsk, semcntが要求ノードで表現できる値の範囲外)
+ */
+ER ref_sem(T_RSEM *pk_rsem, ID semid)
+{
+	ER result;
+
+	if(ISVALID_SEMID(semid))
+	{
+		if(ISVALID_PTR(pk_rsem))
+		{
+			T_SEMCB *p_semcb;
+
+			EnterCriticalSection();
+
+			p_semcb = &(semcbs[semid]);
+
+			if(0 != p_semcb->semid)
+			{
+				pk_rsem->exinf = p_semcb->exinf;
+				pk_rsem->wtsk = (lst_empty(&(p_semcb->wtsklst))) ? FALSE : ((T_TCB *)(p_semcb->wtsklst.p_next))->tskid;
+				pk_rsem->semcnt = p_semcb->semcnt;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+#if 0
+/*--------------------------------------------------------------------------*/
+/*             自タスクの持っているセマを解放する（終了処理専用）           */
+/*--------------------------------------------------------------------------*/
+ER edel_sem(ID semid)
+{
+	ER ercd;
+	T_SEMCB *p_semq;
+	T_TCB *p_tcb;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if((semid < 0) || (TNUM_SEM <= semid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_semq = &(semcbs[semid]);
+
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	if(p_semq->tskid != p_tcb->tskid)
+	{
+		/* 自タスクがセマを獲得していない場合 */
+		return E_OBJ;
+	}
+
+	if(p_semq->head == NULL)
+	{
+		/*- セマフォ待ちのタスクがない -*/
+		p_semq->semcnt = 1;
+		p_semq->tskid = 0;
+	}
+	else
+	{
+		/*- 待ちタスクに資源を与える -*/
+
+		p_tcb = p_semq->head;					/* 先頭のセマ待ちタスク  */
+		del_semq(p_semq, p_tcb);						/* SEMQ から TCB を外す  */
+		add_rdq(p_tcb);							/* RDQ に TCB をつなげる */
+		p_tcb->tskstat = TTS_RDY;					/* タスク状態を READY に */
+		p_tcb->tskwait = 0;
+		p_tcb->wid = 0;
+		p_semq->tskid = p_tcb->tskid;			/* タスクを記録 */
+	}
+
+	/* ディスパッチされるまで待つ */
+	tsk_wait_dispatch();
+
+	return E_OK;
+}
+
+/*--------------------------------------------------------------------------*/
+/*	セマフォに対する信号操作( 別タスクで獲得したセマフォに対しても有効 )	*/
+/*--------------------------------------------------------------------------*/
+ER fsig_sem(ID semid)
+{
+	T_SEMCB *p_semq;
+	T_TCB *p_tcb;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if((semid < 0) || (TNUM_SEM <= semid))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	p_semq = &(semcbs[semid]);
+
+	if(NULL == p_semq->head)
+	{
+		/*----------------- セマフォ待ちのタスクがない ------------------*/
+		(p_semq->semcnt)++;						/* キューイング */
+
+		p_semq->tskid = 0;					/* セマを持っているタスクはない */
+
+		if(0 == p_semq->semcnt)					/* キューイングのオーバフロー */
+		{
+			(semcbs->semcnt)--;
+			return E_QOVR;
+		}
+	}
+	else
+	{
+		/*------------------ 待ちタスクに資源を与える -------------------*/
+		p_tcb = semcbs->head;						/* 先頭のセマ待ちタスク  */
+
+		del_semq(p_semq, p_tcb);						/* SEMQ から TCB を外す  */
+
+		if(p_tcb->tskstat & TTS_SUS)
+		{
+			/* 二重待ち状態 */
+			p_tcb->tskstat = TTS_SUS;				/* タスク状態を SUSPEND に */
+		}
+		else
+		{
+			/* メッセージ待ち状態 */
+			p_tcb->tskstat = TTS_RDY;				/* タスク状態を READY に */
+			p_tcb->tskwait = 0;
+			p_tcb->wid = 0;
+			add_rdq(p_tcb);						/* RDQ に TCB をつなげる */
+		}
+
+		p_semq->tskid = p_tcb->tskid;	/* セマを持っているタスクを記録しておく */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+}
+#endif
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */

--- /dev/null
+++ b/src/sem.h
@@ -0,0 +1,17 @@
+#ifndef _SEM_H_
+#define _SEM_H_
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif	/* defined(__cplusplus) */
+
+#include <itron.h>
+
+ER sem_initialize(void);
+void sem_terminate(void);
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */
+
+#endif	/* _SEM_H_ */

--- /dev/null
+++ b/src/sys.c
@@ -0,0 +1,198 @@
+/**
+ * @file	sys.c
+ * @brief
+ */
+#include "sys.h"
+#include "it3_common.h"
+#include "it3_config.h"
+
+#define	ISVALID_FNCD(fncd)		((0 < (fncd)) && ((fncd) < TNUM_SVC))
+#define	ISVALID_SVCATR(svcatr)	(TRUE)	/* 属性値はチェックしない */
+
+#define	ISVALID_EXCKIND(exckind)	((0 < (exckind)) && ((exckind) < TNUM_EXC))
+#define	ISVALID_EXCATR(excatr)		(TRUE)	/* 属性値はチェックしない */
+
+typedef struct S_SVCCB
+{
+	FN			s_fncd;
+
+	ATR			svcatr;		/* 拡張SVCハンドラ属性 */
+	FP			svchdr;		/* 拡張SVCハンドラアドレス */
+} T_SVCCB;
+
+typedef struct S_EXCCB
+{
+	UINT		exckind;
+
+	ATR			excatr;		/* 例外ハンドラ属性 */
+	FP			exchdr;		/* 例外ハンドラアドレス */
+} T_EXCCB;
+
+
+static const T_SVCCB svccb_initializer = {0};
+
+static const T_EXCCB exccb_initializer = {0};
+
+static T_SVCCB svccbs[TNUM_SVC];
+
+static T_EXCCB exccbs[TNUM_EXC];
+
+ER sys_initialize(void)
+{
+	INT cnt;
+
+	for(cnt = 0;cnt < TNUM_SVC;cnt++)
+	{
+		svccbs[cnt] = svccb_initializer;
+	}
+
+	return E_OK;
+}
+
+void sys_terminate(void)
+{
+}
+
+ER get_ver(T_VER *pk_ver)
+{
+	ER result;
+
+	if(ISVALID_PTR(pk_ver))
+	{
+		pk_ver->maker = TKERNEL_MAKER;
+		pk_ver->id = TKERNEL_PRID;
+		pk_ver->spver = TKERNEL_SPVER;
+		pk_ver->prver = TKERNEL_PRVER;
+		pk_ver->prno[0] = TKERNEL_PRNO0;
+		pk_ver->prno[1] = TKERNEL_PRNO1;
+		pk_ver->prno[2] = TKERNEL_PRNO2;
+		pk_ver->prno[3] = TKERNEL_PRNO3;
+		pk_ver->cpu = TKERNEL_CPU;
+		pk_ver->var = TKERNEL_VAR;
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+ER ref_sys(T_RSYS *pk_rsys)
+{
+	ER result;
+
+	if(ISVALID_PTR(pk_rsys))
+	{
+		pk_rsys->sysstat = 0;	// TODO どうしよっかなー
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+ER ref_cfg(T_RCFG *pk_rcfg)
+{
+	ER result;
+
+	if(ISVALID_PTR(pk_rcfg))
+	{
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+ER def_svc(FN s_fncd, T_DSVC *pk_dsvc)
+{
+	ER result;
+
+	if(ISVALID_FNCD(s_fncd))
+	{
+		T_SVCCB *p_svccb;
+
+		p_svccb = &(svccbs[s_fncd]);
+
+		if(ISVALID_PTR(pk_dsvc))
+		{
+			if(ISVALID_SVCATR(pk_dsvc->svcatr))
+			{
+				*p_svccb = svccb_initializer;
+
+				p_svccb->s_fncd = s_fncd;
+				p_svccb->svcatr = pk_dsvc->svcatr;
+				p_svccb->svchdr = pk_dsvc->svchdr;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_RSATR;
+			}
+		}
+		else
+		{
+			*p_svccb = svccb_initializer;
+			result = E_OK;
+		}
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+ER def_exc(UINT exckind, T_DEXC *pk_dexc)
+{
+	ER result;
+
+	if(ISVALID_EXCKIND(exckind))
+	{
+		T_EXCCB *p_exccb;
+
+		p_exccb = &(exccbs[exckind]);
+
+		if(ISVALID_PTR(pk_dexc))
+		{
+			if(ISVALID_SVCATR(pk_dexc->excatr))
+			{
+				*p_exccb = exccb_initializer;
+
+				p_exccb->exckind = exckind;
+				p_exccb->excatr = pk_dexc->excatr;
+				p_exccb->exchdr = pk_dexc->exchdr;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_RSATR;
+			}
+		}
+		else
+		{
+			*p_exccb = exccb_initializer;
+			result = E_OK;
+		}
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}

--- /dev/null
+++ b/src/sys.h
@@ -0,0 +1,9 @@
+#ifndef _SYS_H_
+#define _SYS_H_
+
+#include <itron.h>
+
+ER sys_initialize(void);
+void sys_terminate(void);
+
+#endif /* _SYS_H_ */

--- /dev/null
+++ b/src/tim.c
@@ -0,0 +1,119 @@
+#include "tim.h"
+#include "it3_common.h"
+#include <depend.h>
+#include "kernel.h"
+#include "que_ctl.h"
+
+#include "alm.h"
+#include "cyc.h"
+
+static UINT last_time = 0;
+SYSTIME systime = {0, 0};
+
+ER tim_initialize(void)
+{
+	return E_OK;
+}
+
+void tim_terminate(void)
+{
+}
+
+/* タイムイベントハンドラ */
+ER tim_event(void)
+{
+	int steptime, now_time;
+
+	/* 現在時刻を取得 */
+	now_time = depend_get_time();
+
+	/* 経過時間を算出 */
+	steptime = now_time - last_time;
+
+	systime.ltime += steptime;
+
+	/* アラームタイマ */
+	alm_timeevent(steptime);
+
+	/* 周期タイマ */
+	cyc_timeevent(steptime);
+
+	/* 現在時刻を保存 */
+	last_time = now_time;
+
+	return E_OK;
+}
+
+/* タイムティックの供給 */
+ER isig_tim(void)
+{
+	systime.ltime += 1;		/* invoked every 1msec */
+	if(systime.ltime < 1)
+	{
+		systime.utime++;
+	}
+
+	os_timer();
+
+	return E_OK;
+}
+
+ER set_tim(SYSTIME *pk_tim)
+{
+	depend_EnterCriticalSection();
+
+	systime = *pk_tim;
+
+	depend_LeaveCriticalSection();
+
+	return E_OK;
+}
+
+/* システム時刻の参照 */
+ER get_tim(SYSTIME *p_systim)
+{
+	ER result;
+
+	if(ISVALID_PTR(p_systim))
+	{
+		*p_systim = systime;
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/* 自タスクの遅延 */
+ER dly_tsk(DLYTIME dlytim)
+{
+	ER ercd;
+	T_TCB *p_tcb;
+
+//	if(DSPENA == OFF)
+//	{
+//		return E_CTX;	/* コンテキストエラー */
+//	}
+
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+
+	del_rdq(p_tcb);								/* TCB を RDQ から外す */
+	p_tcb->tskstat = TTS_WAI;				/* タスク状態は時間経過待ちに */
+	p_tcb->tskwait = TTW_DLY;				/* タスク状態は時間経過待ちに */
+	p_tcb->wid = 0;
+	p_tcb->tmout = timq.time + dlytim;			/* タイムアウト時刻を設定 */
+	add_timq(p_tcb);							/* 時間待ち行列につなぐ */
+
+	/* ディスパッチされるまで待つ */
+	tsk_wait_dispatch();
+
+	return E_OK;
+}
+
+void ret_tmr(void)
+{
+}

--- /dev/null
+++ b/src/tim.h
@@ -0,0 +1,28 @@
+#ifndef _TIM_H_
+#define _TIM_H_
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif	/* defined(__cplusplus) */
+
+#include <itron.h>
+#include "tsk.h"
+
+/* タイマキュー管理ブロック(TIMQ) */
+typedef struct S_TIMQ
+{
+	T_TCB		*head;							/* 先頭TCBへのポインタ		*/
+	TMO			time;							/* 論理タイマ値				*/
+} T_TIMQ;
+
+ER tim_initialize(void);
+void tim_terminate(void);
+
+/* タイムイベントハンドラ */
+ER tim_event(void);
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */
+
+#endif	/* _TIM_H_ */

--- /dev/null
+++ b/src/tsk.c
@@ -0,0 +1,1563 @@
+#include "tsk.h"
+#include "it3_debug.h"
+#include "it3_common.h"
+#include <depend.h>
+
+#include "kernel.h"
+#include "que_ctl.h"
+
+
+#define	ISVALID_TSKID(tskid)	((0 < (tskid)) && ((tskid) < TNUM_TSK))
+#define	ISVALID_TSKPRI(tskpri)	((0 < (tskpri)) || ((tskpri) < TNUM_TSK))
+
+#define	NCT						(0)
+
+static const T_TCB tcb_initializer = {0};
+
+
+/**
+ * @brief	タスク起動用スレッド関数
+ * @param	p_arg			スレッドの引数
+ * @desc	tskidで指定されるID番号を持つタスクを、pk_ctskで指定されるタスク生成情報に基づいて生成する。
+ */
+static void task_crt_function(void *p_arg)
+{
+	T_TCB *p_tcb = (T_TCB *)p_arg;
+	ID tskid;
+	FP task;
+	VP arg;
+
+	IT3_ASSERT(p_tcb);
+
+	depend_EnterCriticalSection();
+
+	tskid = p_tcb->tskid;
+	task = p_tcb->task;
+	arg = p_tcb->arg;
+
+	depend_LeaveCriticalSection();
+
+	IT3_ASSERT(ISVALID_TSKID(tskid));
+	IT3_ASSERT(task);
+	IT3_ASSERT(arg);
+
+
+	IT3_LOG1("task start.[tskid:%d]", tskid);
+	(task)(arg);
+	IT3_LOG1("task end.[tskid:%d]", tskid);
+
+	/* タスク終了 */
+	depend_DestoryTask(tskid);
+}
+
+#if 0
+/*--------------------------------------------------------------------------*/
+/*                     TCB を終了処理実行状態にする                         */
+/*--------------------------------------------------------------------------*/
+ER end_func_set(ID tskid)
+{
+	T_TCB *p_tcb;
+//	UH i;
+//	UW *sp;
+//	FP TaskStart;
+
+	/*-------------------- パラメータエラー判定 ---------------------*/
+	if((tskid < 0) || (TNUM_TSK <= tskid ))
+	{
+		/* ＩＤ範囲外 */
+		return E_ID;
+	}
+
+	if(TSK_SELF == tskid)
+	{
+		/* 自タスクの指定 */
+		return E_ID;
+	}
+
+	p_tcb = &(tcb[tskid]);
+
+	if(NCT == p_tcb->tskstat)
+	{
+		/* タスクが未登録 */
+		return E_NOEXS;
+	}
+
+	p_tcb->pri		= p_tcb->endpri;
+	p_tcb->tskstat	= TTS_DMT;
+	p_tcb->tskwait	= 0;
+	p_tcb->wid		= 0;
+	p_tcb->next		= NULL;
+	p_tcb->prev		= NULL;
+	p_tcb->wfmode	= 0;
+	p_tcb->waiptn	= 0;
+	p_tcb->wupcnt	= 0;
+	p_tcb->suscnt	= 0;
+	p_tcb->tmout	= 0;
+	p_tcb->arg		= NULL;
+	/*p_tcb->sp		= p_tcb->stack;*//*	'94.01.30	c/o	*/
+//	p_tcb->susmask	= FREE;
+
+	/*------------------ レジスタスタックの設定 -------------------*/
+	sp = (UW *)tcb->sp;
+
+	sp--;	*sp = (UW)TaskStart;		/*	PR		*//* <- v82 */
+	sp--;	*sp = 0x40000000;			/*	SR		*/
+	sp--;	*sp = (UW)tcb->end_func;	/*	PC		*/
+
+	sp--;	*sp = 0x00000000;			/*	R0		*/
+	sp--;	*sp = 0x00000000;			/*	R1		*/
+	sp--;	*sp = 0x00000000;			/*	R2		*/
+	sp--;	*sp = 0x00000000;			/*	R3		*/
+	sp--;	*sp = 0x00000000;			/*	R4		*/
+	sp--;	*sp = 0x00000000;			/*	R5		*/
+	sp--;	*sp = 0x00000000;			/*	R6		*/
+	sp--;	*sp = 0x00000000;			/*	R7		*/
+
+	sp--;	*sp = FPSCR_DEF;			/*	FPSCR	*//* add FPSCR */
+
+	sp--;	*sp = 0x00000000;			/*	R8		*/
+	sp--;	*sp = 0x00000000;			/*	R9		*/
+	sp--;	*sp = 0x00000000;			/*	R10		*/
+	sp--;	*sp = 0x00000000;			/*	R11		*/
+	sp--;	*sp = 0x00000000;			/*	MACL	*/
+	sp--;	*sp = 0x00000000;			/*	R12		*/
+	sp--;	*sp = 0x00000000;			/*	MACH	*/
+	sp--;	*sp = 0x00000000;			/*	R13		*/
+	sp--;	*sp = 0x00000000;			/*	GBR		*/
+	sp--;	*sp = 0x00000000;			/*	R14		*/
+
+	/*------------------ FPUレジスタスタックの設定 ----------------*/
+	sp--;	*sp = 0x00000000;			/*	FPUL	*/
+	sp--;	*sp = FPSCR_DEF;			/*	FPSCR	*/
+	sp--;	*sp = 0x00000000;			/*	FR15	*/
+	sp--;	*sp = 0x00000000;			/*	FR14	*/
+	sp--;	*sp = 0x00000000;			/*	FR13	*/
+	sp--;	*sp = 0x00000000;			/*	FR12	*/
+	sp--;	*sp = 0x00000000;			/*	FR11	*/
+	sp--;	*sp = 0x00000000;			/*	FR10	*/
+	sp--;	*sp = 0x00000000;			/*	FR9		*/
+	sp--;	*sp = 0x00000000;			/*	FR8		*/
+	sp--;	*sp = 0x00000000;			/*	FR7		*/
+	sp--;	*sp = 0x00000000;			/*	FR6		*/
+	sp--;	*sp = 0x00000000;			/*	FR5		*/
+	sp--;	*sp = 0x00000000;			/*	FR4		*/
+	sp--;	*sp = 0x00000000;			/*	FR3		*/
+	sp--;	*sp = 0x00000000;			/*	FR2		*/
+	sp--;	*sp = 0x00000000;			/*	FR1		*/
+	sp--;	*sp = 0x00000000;			/*	FR0		*/
+	sp--;	*sp = 0x00000000;			/*	XF15	*/
+	sp--;	*sp = 0x00000000;			/*	XF14	*/
+	sp--;	*sp = 0x00000000;			/*	XF13	*/
+	sp--;	*sp = 0x00000000;			/*	XF12	*/
+	sp--;	*sp = 0x00000000;			/*	XF11	*/
+	sp--;	*sp = 0x00000000;			/*	XF10	*/
+	sp--;	*sp = 0x00000000;			/*	XF9		*/
+	sp--;	*sp = 0x00000000;			/*	XF8		*/
+	sp--;	*sp = 0x00000000;			/*	XF7		*/
+	sp--;	*sp = 0x00000000;			/*	XF6		*/
+	sp--;	*sp = 0x00000000;			/*	XF5		*/
+	sp--;	*sp = 0x00000000;			/*	XF4		*/
+	sp--;	*sp = 0x00000000;			/*	XF3		*/
+	sp--;	*sp = 0x00000000;			/*	XF2		*/
+	sp--;	*sp = 0x00000000;			/*	XF1		*/
+	sp--;	*sp = 0x00000000;			/*	XF0		*/
+
+	tcb->sp = (VB *)sp;
+
+	return E_OK;
+}
+#endif
+
+#if 0 // TODO
+void add_rdq(T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_tcb);
+
+	lst_insert(&(rdq[p_tcb->tskpri]), (T_LST *)p_tcb);
+}
+
+void del_rdq(T_TCB *p_tcb)
+{
+	IT3_ASSERT(p_tcb);
+
+	lst_delete((T_LST *)p_tcb);
+}
+#endif
+
+/**
+ * @brief	タスクシステムの初期化
+ */
+ER tsk_initialize(void)
+{
+	INT cnt;
+
+	/* TCBの初期化 */
+	for(cnt = 0;cnt < TNUM_TSK;cnt++)
+	{
+		tcb[cnt] = tcb_initializer;
+	}
+
+	/* RDQの初期化 */
+	for(cnt = 0;cnt < TNUM_TSK;cnt++)
+	{
+		lst_init(&(rdq[cnt]));
+	}
+
+	return E_OK;
+}
+
+/**
+ * @brief	タスクシステムの終了
+ */
+void tsk_terminate(void)
+{
+}
+
+ER kernel_cre_tsk(T_TCB *p_tcb)
+{
+	ER result;
+	T_DEPEND_CTSK ctsk;
+	int ret;
+
+	IT3_ASSERT(p_tcb);
+
+	ctsk.stksz = p_tcb->stksz;
+	ctsk.p_func = task_crt_function;
+	ctsk.p_param = p_tcb;
+
+	ret = depend_CreateTask(p_tcb->tskid, &ctsk);
+	if(0 == ret)
+	{
+		result = E_OK;
+	}
+	else
+	{
+		result = E_SYS;
+	}
+
+	return result;
+}
+
+/*
+ * @brief	自タスクのIDを得る
+ * @param	p_tskid	自タスクIDを格納するバッファのアドレス
+ * @return	戻り値
+ * @retval	E_OK	取得成功
+ * @retval	E_OK以外	取得失敗
+ */
+ER kernel_tsk_get_self_tskid(ID *p_tskid)
+{
+	ER result;
+	T_TCB *p_tcb;
+
+	IT3_ASSERT(ISVALID_PTR(p_tskid));
+
+	p_tcb = (T_TCB *)depend_GetParam();
+	if(p_tcb)
+	{
+		*p_tskid = p_tcb->tskid;
+
+		result = E_OK;
+	}
+	else
+	{
+		result = E_CTX;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	TCBを得る
+ */
+ER tsk_get_tcb(ID tskid, T_TCB** pp_tcb)
+{
+	ER result;
+	T_TCB *p_tcb;
+
+	IT3_ASSERT(ISVALID_TSKID(tskid) || (TSK_SELF == tskid));
+	IT3_ASSERT(ISVALID_PTR(pp_tcb));
+
+	if(TSK_SELF == tskid)
+	{
+		p_tcb = (T_TCB *)depend_GetParam();
+	}
+	else
+	{
+		p_tcb = &(tcb[tskid]);
+	}
+
+	if(ISVALID_PTR(p_tcb))
+	{
+		*pp_tcb = p_tcb;
+		result = E_OK;
+	}
+	else
+	{
+		result = E_CTX;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	ディスパッチされるまで待つ
+ */
+void tsk_wait_dispatch(void)
+{
+	T_TCB *p_tcb;
+
+	p_tcb = (T_TCB *)depend_GetParam();
+	if(p_tcb)
+	{
+		IT3_LOG1("Sleep task[tskid:%d].Wake up kernel.", p_tcb->tskid);
+
+		depend_SwitchTask(0);
+	}
+	else
+	{
+		/* この制御はタスクじゃない（つまりカーネル）、
+			制御を切り替える必要が無い	*/
+	}
+
+}
+
+/**
+ * @brief	タスクをディスパッチする
+ */
+void tsk_dispatch(void)
+{
+	INT cnt;
+	T_LST *p_rdq;
+	T_TCB *p_tcb = NULL;
+
+//カーネルデバッグ用
+#if 0
+	for(cnt = 0;cnt < (sizeof(rdq) / sizeof(rdq[0]));cnt++)
+	{
+		p_rdq = &(rdq[cnt]);
+
+		IT3_LOG1("rdq[%d]", cnt);
+
+		p_tcb = p_rdq->head;
+		while(p_tcb)
+		{
+			IT3_LOG2("  ID:%d, NAME:%s", p_tcb->tskid, p_tcb->name);
+			p_tcb = p_tcb->next;
+
+			if(p_tcb == p_rdq->head)
+			{
+				break;
+			}
+		}
+
+		IT3_LOG("  NULL");
+	}
+#endif /* 0 */
+//カーネルデバッグ用
+
+	/* レディーキューから、次に起動するタスクを取得する */
+	for(cnt = 0;cnt < (sizeof(rdq) / sizeof(rdq[0]));cnt++)
+	{
+		p_rdq = &(rdq[cnt]);
+
+		if(! lst_empty(p_rdq))
+		{
+			p_tcb = (T_TCB *)(p_rdq->p_next);
+			break;
+		}
+	}
+
+	if(p_tcb)							/* 実行可能タスクがある?	*/
+	{
+		IT3_LOG1("Wake up task.[tskid:%d]", p_tcb->tskid);
+		depend_SwitchTask(p_tcb->tskid);
+	}
+
+	depend_sleep(1);
+}
+
+void tsk_wait_delete(T_LST *p_wtsklst)
+{
+	IT3_ASSERT(p_wtsklst);
+}
+
+void tsk_wait_release(T_TCB *p_tcb, ER ercd)
+{
+	IT3_ASSERT(p_tcb);
+	IT3_ASSERT(0 != p_tcb->tskid);
+
+	lst_delete((T_LST *)p_tcb);
+
+	IT3_ASSERT(p_tcb->p_wercd);
+
+	*(p_tcb->p_wercd) = ercd;
+
+	if(p_tcb->tskstat & TTS_SUS)
+	{
+		/* 二重待ち状態 */
+		p_tcb->tskstat = TTS_SUS;				/* タスク状態を SUSPEND に	*/
+	}
+	else
+	{
+		p_tcb->tskstat = TTS_RDY;				/* タスク状態を READY に */
+		p_tcb->tskwait = 0;
+		p_tcb->wid = 0;
+
+		/* メッセージ待ち状態 */
+		add_rdq(p_tcb);						/* RDQ に TCB をつなげる */
+	}
+}
+
+/*
+ * ==========================================================================
+ * rst_tsk
+ *【機能】
+ *	TCBを初期状態に戻す
+ *【引数】
+ *		ID		tskid			タスクID
+ *【戻り値】
+ *		E_OK		正常終了
+ *		E_IDOVR		ID範囲外
+ *		E_NOEXS		オブジェクトが存在していない(tskidのタスクが存在しない)
+ *		E_NODMT		タスクがDORMANTでない(tskidのタスクがDORMANTでない)
+ *		E_OBJ		オブジェクト状態エラー
+ *【解説】
+ *	tskidで示されたタスクのTCBを初期状態に戻す。
+ * ==========================================================================
+ */
+ER rst_tsk(ID tskid )
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_TCB *p_tcb;
+
+		p_tcb = &(tcb[tskid]);
+
+		if(NCT != p_tcb->tskstat)
+		{
+			p_tcb->tskpri		= p_tcb->itskpri;
+			p_tcb->tskstat	= TTS_DMT;
+			p_tcb->tskwait	= 0;
+			p_tcb->wid		= 0;
+			p_tcb->next		= NULL;
+			p_tcb->prev		= NULL;
+//			p_tcb->wfmode	= 0;
+//			p_tcb->waiptn	= 0;
+			p_tcb->wupcnt	= 0;
+			p_tcb->suscnt	= 0;
+			p_tcb->tmout	= 0;
+			p_tcb->arg		= NULL;
+//			p_tcb->susmask	= FREE;
+
+			result = E_OK;
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * cre_tsk
+ * @brief	タスクを生成する
+ * @param	tskid	タスクID
+ * @param	pk_ctsk	タスク生成情報のポインタ
+ * @return	エラーコード
+ * @retval	E_OK		正常終了
+ * @retval	E_IDOVR		不正ID番号
+ * @retval	E_NOMEM		メモリ不足
+ * @retval	E_RSATR		予約属性
+ * @retval	E_PAR		パラメータエラー
+ * @retval	E_OBJ		オブジェクト状態エラー
+ *
+ *	tskidで指定されるID番号を持つタスクを、pk_ctskで指定されるタスク生成
+ *	情報に基づいて生成する。
+ */
+ER cre_tsk(ID tskid, T_CTSK *pk_ctsk)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))				/* タスクIDが範囲内?			*/
+	{
+		if(ISVALID_PTR(pk_ctsk))
+		{
+			T_TCB *p_tcb;
+			T_TCBTMO *p_tcbtmo;
+
+			p_tcb = &(tcb[tskid]);
+
+			depend_EnterCriticalSection();
+
+			if(0 == p_tcb->tskid)
+			{
+				*p_tcb = tcb_initializer;
+
+				lst_init(&(p_tcb->lst));
+
+				p_tcb->tskid	= tskid;
+
+				p_tcb->exinf = pk_ctsk->exinf;
+				p_tcb->tskatr = pk_ctsk->tskatr;
+				p_tcb->task = pk_ctsk->task;
+				p_tcb->itskpri = pk_ctsk->itskpri;
+				p_tcb->stksz = pk_ctsk->stksz;
+
+				p_tcb->tskpri = pk_ctsk->itskpri;
+				p_tcb->tskstat = TTS_DMT;
+				p_tcb->tskwait = 0;
+				p_tcb->wid = 0;
+				p_tcb->wupcnt = 0;
+				p_tcb->suscnt = 0;
+
+				p_tcb->p_wercd = NULL;
+//				p_tcb->wfmode = 0;
+//				p_tcb->waiptn = 0;
+
+
+//				p_tcb->pri		= pk_ctsk->itskpri;
+//				p_tcb->sts		= TTS_DMT;
+//				p_tcb->wid		= 0;
+				p_tcb->next		= NULL;
+				p_tcb->prev		= NULL;
+
+				p_tcb->tmout	= 0;
+				p_tcb->arg		= NULL;
+
+//				p_tcb->sta_func	= pk_ctsk->task;
+//				p_tcb->end_func	= NULL;
+//				p_tcb->stack	= stack + pk_ctsk->stksz;
+
+//				p_tcb->endpri	= 0x1;
+//				p_tcb->susmask	= FREE;
+//				p_tcb->ipri		= pk_ctsk->itskpri;
+
+//				p_tcb->size		= pk_ctsk->stksz / 1024;
+//				p_tcb->r_size	= p_tcb->size;
+//				p_tcb->scp		= (UW*)(stack + pk_ctsk->stksz);
+
+//				strncpy(p_tcb->name, pk_ctsk->name, sizeof(p_tcb->name) - 1);
+
+				p_tcbtmo		= &(tcbtmoq[tskid]);
+
+				p_tcbtmo->tskid	= tskid;
+				p_tcbtmo->sts	= 0;
+				p_tcbtmo->next	= p_tcbtmo->prev = 0;
+				p_tcbtmo->tmout	= 0;
+				p_tcbtmo->tcb	= p_tcb;
+
+				/* タスク生成 */
+				kernel_cre_tsk(p_tcb);
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	タスクの削除
+ */
+ER del_tsk(ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_TCB *p_tcb;
+
+		p_tcb = &(tcb[tskid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_tcb->tskid)
+		{
+			if(TTS_DMT == p_tcb->tskstat)
+			{
+				*p_tcb = tcb_initializer;
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * sta_tsk
+ *
+ * @brief	タスクを起動する
+ *
+ * @param	tskid	タスクID
+ * @return	エラーコード
+ * @retval	E_OK	正常終了
+ * @retval	E_IDOVR	ID範囲外(インプリメント依存)
+ * @retval	E_NOEXS	オブジェクトが存在していない(tskidのタスクが存在しない)
+ * @retval	E_NODMT	タスクがDORMANTでない(tskidのタスクがDORMANTでない)
+ * @retval	E_OBJ	オブジェクト状態エラー
+ *
+ * tskidで示されたタスクを起動する。
+ */
+ER sta_tsk(ID tskid, INT stacd)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_TCB *p_tcb;
+
+		p_tcb = &(tcb[tskid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_tcb->tskid)
+		{
+			if(TTS_DMT == p_tcb->tskstat)
+			{
+				rst_tsk(tskid);								/* TCB を初期状態に戻す		*/
+
+				p_tcb->tskstat = TTS_RDY;						/* タスク状態を READY にする	*/
+				p_tcb->tskwait = 0;
+				p_tcb->wid = 0;
+				add_rdq(p_tcb);								/* TCB を RDQ につなぐ		*/
+
+				/* ディスパッチされるまで待つ */
+				tsk_wait_dispatch();
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/**
+ * @brief	自タスクを正常終了する
+ */
+void ext_tsk(void)
+{
+	ER ercd;									/* 呼び出した関数の戻り値	*/
+	T_TCB *p_tcb;
+
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK == ercd)
+	{
+		depend_EnterCriticalSection();
+
+		del_rdq(p_tcb);								/* RDQ から TCB を外す		*/
+
+		p_tcb->tskstat = TTS_DMT;
+		p_tcb->tskwait = 0;
+		p_tcb->wid = 0;
+
+	//	DSPENA = ON;								/* ディスパッチ許可状態		*/
+
+		depend_LeaveCriticalSection();
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+}
+
+/**
+ * @brief	自タスクの終了と削除
+ */
+void exd_tsk(void)
+{
+	ER ret;
+	T_TCB *p_tcb;
+
+	ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK == ret)
+	{
+		depend_EnterCriticalSection();
+		del_rdq(p_tcb);								/* RDQ から TCB を外す */
+
+		p_tcb->tskstat = NCT;
+
+//		DSPENA = ON;	/* ディスパッチ許可状態 */
+
+		depend_LeaveCriticalSection();
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+}
+
+
+/**
+ * @brief	他タスクを強制的に異常終了させる
+ */
+ER ter_tsk(ID tskid)
+{
+	ER ercd;									/* 呼び出した関数の戻り値	*/
+	UINT tsksts;
+	UINT waists;
+	T_TCB *p_tcb;
+
+	/*==============*/
+	/* 引数チェック */
+	/*==============*/
+	if(! ISVALID_TSKID(tskid))		/* タスクIDが範囲外?		*/
+	{
+		return E_ID;
+	}
+
+	if(TSK_SELF == tskid)
+	{
+		/* 自タスクの指定 */
+		return E_ID;
+	}
+
+	/*************/
+	/* TCBを取得 */
+	/*************/
+	ercd = tsk_get_tcb(tskid, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	tsksts = p_tcb->tskstat;				/* タスクの状態				*/
+	waists = p_tcb->tskwait;				/* 待ちの種類				*/
+
+	if(NCT == tsksts)
+	{
+		/* タスクが未登録 */
+		return E_NOEXS;
+	}
+
+	if(TTS_DMT == tsksts)
+	{
+		/* タスクが DORMANT である */
+		return E_OBJ;
+	}
+
+	/*------------------ TCB を管理ブロックから外す -----------------*/
+	if(TTS_RDY == tsksts)
+	{
+		/* タスクが READY の場合 */
+		del_rdq( p_tcb );			/* RDQ から TCB を外す */
+	}
+	else if(( tsksts == TTS_WAI )||( tsksts == TTS_WAS ))
+	{
+		/* タスクが WAIT or WAIT-SUSPEND の場合  */
+
+		switch(waists)
+		{
+			case WTIM:	/* 時間待ち */
+			case TTW_DLY:	/* 時間経過待ち */
+				del_timq( p_tcb );	/* TIMQ から TCB を外す */
+				break;
+
+			case TTW_FLG:	/* イベントフラグ待ち */
+//				del_flgq(NULL, p_tcb);				/* FLGQ から TCB を外す */
+				lst_delete((T_LST *)p_tcb);
+				break;
+
+			case TTW_SEM:  /* セマフォ待ち */
+//				del_semq(NULL, p_tcb);				/* SEMQ から TCB を外す */
+				lst_delete((T_LST *)p_tcb);
+				break;
+
+			case TTW_MBX:	/* メッセージ待ち */
+//				del_mbxq(NULL, p_tcb);				/* MBXQ から TCB を外す */
+				lst_delete((T_LST *)p_tcb);
+				break;
+
+			case (WTIM | TTW_FLG):	/* イベントフラグ待ち */
+//				del_flgq(NULL, p_tcb);				/* FLGQ から TCB を外す */
+				lst_delete((T_LST *)p_tcb);
+				{
+					T_TCBTMO *tcbtmo = &tcbtmoq[tcb->tskid];
+//					del_timq(tcbtmo);				/* TIMQ から TCB を外す */
+					tcbtmo->sts = 0;
+				}
+				break;
+
+			default:	/* 単純待ち */
+				break;
+		}
+	}
+	else
+	{
+		/* タスクが SUSPEND の場合 */
+	}
+#if 0
+	/*---------------------- 終了処理の有無判定 ---------------------*/
+	if(p_tcb->end_func != NULL )
+	{
+		/* 終了処理ルーチンが登録されている */
+
+		end_func_set(p_tcb->tskid);		/* TCB を終了処理実行状態にする */
+
+		add_rdq( p_tcb );			/* TCB を RDQ つなげる */
+		tcb->sts = TTS_RDY;			/* タスク状態を READY にする */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+	else
+	{
+		/* 終了処理ルーチンが登録されていない */
+		tcb->sts = TTS_DMT;
+	}
+#endif
+	return E_OK;
+}
+
+/* ディスパッチを禁止する */
+ER dis_dsp(void)
+{
+//	DSPENA = OFF;			/* ディスパッチ禁止状態	*/
+	return E_OK;
+}
+
+/* ディスパッチを許可する */
+ER ena_dsp(void)
+{
+//	DSPENA = ON;			/* ディスパッチ許可状態	*/
+	return E_OK;
+}
+
+/* タスク優先度を変更する */
+ER chg_pri(ID tskid, PRI tskpri)
+{
+	ER result;
+
+	result = ichg_pri(tskid, tskpri);
+	if(E_OK == result)
+	{
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return result;
+}
+
+/* タスク優先度を変更する (タスク独立部専用) */
+ER ichg_pri(ID tskid, PRI tskpri)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid) || (TSK_SELF == tskid))
+	{
+		if(ISVALID_TSKPRI(tskpri) || (TPRI_INI == tskpri))
+		{
+			ER ret;
+			T_TCB *p_tcb;
+
+			ret = tsk_get_tcb(tskid, &p_tcb);
+			if(E_OK == ret)
+			{
+				depend_EnterCriticalSection();
+
+				if(0 != p_tcb->tskid)
+				{
+					if(TPRI_INI == tskpri)
+					{
+						tskpri = p_tcb->itskpri;
+					}
+
+					if(TTS_RDY == p_tcb->tskstat)
+					{
+						del_rdq(p_tcb);
+						p_tcb->tskpri = tskpri;
+						add_rdq(p_tcb);
+					}
+					else
+					{
+						p_tcb->tskpri = tskpri;
+					}
+
+					result = E_OK;
+				}
+				else
+				{
+					result = E_OBJ;
+				}
+
+				depend_LeaveCriticalSection();
+			}
+			else
+			{
+				result = (E_CTX == ret) ? E_ID : ret;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* タスクのレディキューを回転する */
+ER rot_rdq(PRI tskpri)
+{
+	ER result;
+
+	if(ISVALID_TSKPRI(tskpri) || (TPRI_RUN == tskpri))
+	{
+		ER ret = E_OK;
+
+		if(TPRI_RUN == tskpri)
+		{
+			T_TCB *p_tcb;
+
+			ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+			if(E_OK == ret)
+			{
+				tskpri = p_tcb->tskpri;
+			}
+		}
+
+		if(E_OK == ret)
+		{
+			T_LST *p_rdq;
+
+			p_rdq = &(rdq[tskpri]);
+
+			if(p_rdq->p_next)
+			{
+				T_TCB *p_tcb;
+
+				p_rdq->p_prev = p_rdq->p_next;
+				p_rdq->p_next = (p_rdq->p_next)->p_next;
+
+				ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+				if(E_OK == ret)
+				{
+					/* ディスパッチされるまで待つ */
+					tsk_wait_dispatch();
+
+					result = E_OK;
+				}
+				else
+				{
+					result = ret;
+				}
+			}
+			else
+			{
+				result = E_PAR;
+			}
+		}
+		else
+		{
+			result = ret;
+		}
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/* タスクのレディキューを回転する(タスク独立部専用) */
+ER irot_rdq(PRI tskpri)
+{
+	return E_NOSPT;
+}
+
+/* 他タスクの待ち状態解除 */
+ER rel_wai(ID tskid)
+{
+	return E_NOSPT;
+
+}
+
+/* 他タスクの待ち状態解除(タスク独立部専用) */
+ER irel_wai(ID tskid)
+{
+	return E_NOSPT;
+}
+
+/* 自タスクのIDを得る */
+ER get_tid(ID *p_tskid)
+{
+	return kernel_tsk_get_self_tskid(p_tskid);
+}
+
+ER ref_tsk(T_RTSK *pk_rtsk, ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid) || (TSK_SELF == tskid))
+	{
+		if(ISVALID_PTR(pk_rtsk))
+		{
+			ER ret;
+			T_TCB *p_tcb;
+
+			ret = tsk_get_tcb(tskid, &p_tcb);
+			if(E_OK == ret)
+			{
+				depend_EnterCriticalSection();
+
+				pk_rtsk->exinf = p_tcb->exinf;
+				pk_rtsk->tskpri = p_tcb->tskpri;
+				pk_rtsk->tskstat = p_tcb->tskstat;
+
+				pk_rtsk->tskwait = p_tcb->tskwait;
+				pk_rtsk->wid = p_tcb->wid;
+				pk_rtsk->wupcnt = p_tcb->wupcnt;
+				pk_rtsk->suscnt = p_tcb->suscnt;
+
+				depend_LeaveCriticalSection();
+
+				result = E_OK;
+			}
+			else
+			{
+				result = ret;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/* 他タスクを強制待ち状態へ移行 */
+ER sus_tsk(ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		ER ret;
+		T_TCB *p_tcb;
+
+		ret = tsk_get_tcb(tskid, &p_tcb);
+		if(E_OK == ret)
+		{
+			depend_EnterCriticalSection();
+
+			if(0 != p_tcb->tskid)
+			{
+				if(TTS_DMT != p_tcb->tskstat)
+				{
+					result = E_OK;
+
+					if(TTS_RDY == p_tcb->tskstat)
+					{
+						del_rdq(p_tcb);
+						p_tcb->tskstat = TTS_SUS;
+						p_tcb->tskwait = 0;
+						p_tcb->wid = 0;
+					}
+					else if(TTS_WAI == p_tcb->tskstat)
+					{
+						p_tcb->tskstat = TTS_SUS;
+						p_tcb->tskwait = 0;
+						p_tcb->wid = 0;
+					}
+					else if((TTS_SUS == p_tcb->tskstat) || (TTS_WAS == p_tcb->tskstat))
+					{
+						if(p_tcb->suscnt < TMAX_SUSCNT)
+						{
+							(p_tcb->suscnt)++;
+						}
+						else
+						{
+							result = E_QOVR;
+						}
+					}
+					else
+					{
+						// not action.
+					}
+
+					if(E_OK == result)
+					{
+						tsk_wait_dispatch();
+					}
+				}
+				else
+				{
+					result = E_OBJ;
+				}
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+
+			depend_LeaveCriticalSection();
+		}
+		else
+		{
+			result = ret;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+ER isus_tsk(ID tskid)
+{
+	return E_NOSPT;
+}
+
+/* 強制待ち状態のタスクを再開 */
+ER rsm_tsk(ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_TCB *p_tcb;
+
+		p_tcb = &(tcb[tskid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_tcb->tskid)
+		{
+			if((TTS_DMT != p_tcb->tskstat) && (TTS_SUS & p_tcb->tskstat))
+			{
+				if(0 < p_tcb->suscnt)
+				{
+					(p_tcb->suscnt)--;
+				}
+				else
+				{
+					p_tcb->tskstat &= ~(TTS_SUS);	/* SUSPEND を解除 */
+
+					if(TTS_WAI != (p_tcb->tskstat & TTS_WAI))
+					{
+						p_tcb->tskstat = TTS_RDY;			/* タスク状態を READY にする */
+						p_tcb->tskwait = 0;
+						p_tcb->wid = 0;
+						add_rdq(p_tcb);					/* RDQ に TCB をつなげる	*/
+
+						/* ディスパッチされるまで待つ */
+						tsk_wait_dispatch();
+					}
+				}
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = (TSK_SELF != tskid) ? E_ID : E_OBJ;
+	}
+
+	return result;
+}
+
+ER irsm_tsk(ID tskid)
+{
+	return E_NOSPT;
+}
+
+ER frsm_tsk(ID tskid)
+{
+	return E_NOSPT;
+}
+
+ER ifrsm_tsk(ID tskid)
+{
+	return E_NOSPT;
+}
+
+/* 自タスクを起床待ち状態へ移行 */
+ER slp_tsk(void)
+{
+	return tslp_tsk(TMO_FEVR);
+}
+
+ER tslp_tsk(TMO tmout)
+{
+	ER result;
+	ER ret;
+	T_TCB *p_tcb;
+
+	if(ISVALID_TMOUT(tmout))
+	{
+		ret = tsk_get_tcb(TSK_SELF, &p_tcb);
+		if(E_OK == ret)
+		{
+			depend_EnterCriticalSection();
+
+			IT3_ASSERT(0 != p_tcb->tskid);
+			IT3_ASSERT(TTS_RUN == p_tcb->tskstat);
+
+			if(0 < p_tcb->wupcnt)
+			{
+				(p_tcb->wupcnt)--;
+			}
+			else
+			{
+				del_rdq(p_tcb);
+
+				p_tcb->tskstat = TTS_WAI;
+
+				if(TMO_FEVR == tmout)
+				{
+					p_tcb->tskwait = 0;
+					p_tcb->wid = 0;
+				}
+				else
+				{
+					p_tcb->tskwait = WTIM;
+					p_tcb->wid = 0;
+
+					p_tcb->tmout = timq.time + tmout;
+					add_timq(p_tcb);
+				}
+
+				/* ディスパッチされるまで待つ */
+				tsk_wait_dispatch();
+			}
+
+			depend_LeaveCriticalSection();
+
+			result = E_OK;
+		}
+		else
+		{
+			result = ret;
+		}
+	}
+	else
+	{
+		result = E_PAR;
+	}
+
+	return result;
+}
+
+/* 他タスクの起床 */
+ER wup_tsk(ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid))
+	{
+		T_TCB *p_tcb;
+
+		p_tcb = &(tcb[tskid]);
+
+		depend_EnterCriticalSection();
+
+		if(0 != p_tcb->tskid)
+		{
+			if(TTS_DMT == p_tcb->tskstat)
+			{
+				result = E_OK;
+
+				if(TTS_WAI == p_tcb->tskstat)
+				{
+					if(WTIM == p_tcb->tskwait)	/* 時間待ち状態? */
+					{
+						del_timq(p_tcb);					/* TIMQからTCBを外す */
+					}
+					else
+					{
+						p_tcb->tskstat = TTS_RDY;				/* タスク状態をREADY */
+						add_rdq(p_tcb);						/* TCBをRDQにつなぐ  */
+					}
+				}
+				else if(TTS_WAS == p_tcb->tskstat)			/* 二重待ち */
+				{
+					if(WTIM == p_tcb->tskwait)	/* 時間待ち状態? */
+					{
+						del_timq(p_tcb);					/* TIMQからTCBを外す */
+					}
+					else
+					{
+						p_tcb->tskstat = TTS_SUS;				/* タスク状態をSUSPEND */
+					}
+				}
+				else
+				{
+					if(p_tcb->wupcnt < TMAX_WUPCNT)
+					{
+						(p_tcb->wupcnt)++;
+					}
+					else
+					{
+						result = E_QOVR;
+					}
+				}
+
+				if(E_OK == result)
+				{
+					/* ディスパッチされるまで待つ */
+					tsk_wait_dispatch();
+				}
+			}
+			else
+			{
+				result = E_OBJ;
+			}
+		}
+		else
+		{
+			result = E_NOEXS;
+		}
+
+		depend_LeaveCriticalSection();
+	}
+	else
+	{
+		result = (TSK_SELF != tskid) ? E_ID : E_OBJ;
+	}
+
+	return result;
+}
+
+ER iwup_tsk(ID tskid)
+{
+	return E_NOSPT;
+}
+
+/* タスクの起床要求を無効化 */
+ER can_wup(INT *p_wupcnt, ID tskid)
+{
+	ER result;
+
+	if(ISVALID_TSKID(tskid) || (TSK_SELF == tskid))
+	{
+		if(ISVALID_PTR(p_wupcnt))
+		{
+			ER ret;
+			T_TCB *p_tcb;
+
+			ret = tsk_get_tcb(tskid, &p_tcb);
+			if(E_OK == ret)
+			{
+				depend_EnterCriticalSection();
+
+				if(0 != p_tcb->tskid)
+				{
+					if(TTS_DMT != p_tcb->tskstat)
+					{
+						*p_wupcnt = p_tcb->wupcnt;
+						p_tcb->wupcnt = 0;
+
+						result = E_OK;
+					}
+					else
+					{
+						result = E_OBJ;
+					}
+				}
+				else
+				{
+					result = E_NOEXS;
+				}
+
+				depend_LeaveCriticalSection();
+			}
+			else
+			{
+				result = (E_CTX == ret) ? E_ID : ret;
+			}
+		}
+		else
+		{
+			result = E_PAR;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+
+/*
+ * =============================================================================
+ * ここから非標準関数の実装
+ * =============================================================================
+ */
+#if 0
+/*
+ * --------------------------------------------------------------------------
+ * タスクを一定時間待ち状態へ移行する
+ * --------------------------------------------------------------------------
+ */
+ER wai_tsk(TMO tmout)
+{
+	ER ercd;									/* 呼び出した関数の戻り値	*/
+	T_TCB *p_tcb;
+
+//	if( DSPENA == OFF )		/* ディスパッチ禁止状態 */
+//	{
+//		return( E_CTX );
+//	}
+
+	ercd = tsk_get_tcb(TSK_SELF, &p_tcb);
+	if(E_OK != ercd)
+	{
+		return ercd;
+	}
+
+	if(0 != p_tcb->wupcnt)						/* 起床要求がある?			*/
+	{
+		/* 起床要求がキューイングされている */
+		(p_tcb->wupcnt)--;
+	}
+	else
+	{
+		/* 起床要求がキューイングされていない */
+		del_rdq(p_tcb);							/* TCBをRDQ から外す      */
+		p_tcb->tskstat = TTS_WAI;				/* タスク状態は時間待ちに */
+		p_tcb->tskwait = WTIM;				/* タスク状態は時間待ちに */
+		p_tcb->wid = 0;
+		p_tcb->tmout = timq.time + tmout;		/* タイムアウト時刻を設定 */
+		add_timq(p_tcb);						/* 時間待ち行列につなぐ   */
+
+		/* ディスパッチされるまで待つ */
+		tsk_wait_dispatch();
+	}
+
+	return E_OK;
+}
+
+/* タスクの状態を見る */
+ER tsk_sts(UINT *p_tskstat, PRI *p_tskpri, ID tskid)
+{
+	ER result;
+
+	/*==============*/
+	/* 引数チェック */
+	/*==============*/
+	if(ISVALID_TSKID(tskid))
+	{
+		ER ret;
+		T_TCB *p_tcb;
+
+		ret = tsk_get_tcb(tskid, &p_tcb);
+		if(E_OK == ret)
+		{
+			if(NCT != p_tcb->sts)
+			{
+				if(p_tskstat)
+				{
+					/*----------------- タスクの状態、優先度を得る ------------------*/
+					if((TTS_RDY == p_tcb->sts) && (TSK_SELF == tskid))
+					{
+						*p_tskstat = TTS_RUN;
+					}
+					else
+					{
+						*p_tskstat = (p_tcb->sts & 0x00ff);
+					}
+				}
+
+				if(p_tskpri)
+				{
+					*p_tskpri  = p_tcb->pri;
+				}
+
+				result = E_OK;
+			}
+			else
+			{
+				result = E_NOEXS;
+			}
+		}
+		else
+		{
+			result = ret;
+		}
+	}
+	else
+	{
+		result = E_ID;
+	}
+
+	return result;
+}
+#endif

--- /dev/null
+++ b/src/tsk.h
@@ -0,0 +1,159 @@
+/**
+ * @file	tsk.h
+ *
+ */
+
+#ifndef _TSK_H_
+#define _TSK_H_
+
+#include <itron.h>
+#include "lst.h"
+
+// TODO 非標準の移植のための暫定措置
+#define	WTIM	(0x4000)
+
+/* 内部用TCB構造体 */
+typedef struct S_TCB
+{
+	T_LST			lst;				/**< list controller					*/
+
+	ID				tskid;				/**< タスクＩＤ番号						*/
+
+	VP				exinf;				/**< 拡張情報							*/
+	ATR				tskatr;				/**< タスク属性							*/
+	FP				task;				/**< タスク起動アドレス					*/
+	PRI				itskpri;			/**< タスク起動時優先度					*/
+	INT				stksz;				/**< スタックサイズ						*/
+
+	PRI				tskpri;				/**< 現在の優先度						*/
+	UINT			tskstat;			/**< タスク状態							*/
+	UINT			tskwait;			/**< 待ち要因							*/
+	ID				wid;				/**< 待ち行列のＩＤ						*/
+	INT				wupcnt;				/**< 起床要求キューイング数				*/
+	INT				suscnt;				/**< SUSPEND要求ネスト数					*/
+
+	ER				*p_wercd;			/**< 待ち結果のアドレス					*/
+
+	union U_WAIT
+	{
+		struct S_WFLG
+		{
+			UINT	wfmode;				/**< フラグ待ちモード						*/
+			UINT	waiptn;				/**< 待ちフラグパターン					*/
+			UINT	flgptn;				/**< 待ち解除時のフラグパターン			*/
+		} wflg;
+
+		struct S_WMBX
+		{
+			T_MSG	**ppk_msg;			/**< メッセージパケットの先頭を入れるアドレス	*/
+		} wmbx;
+
+		struct S_WMBF
+		{
+			VP		msg;				/**< 受信メッセージを入れるアドレス		*/
+			INT		msgsz;				/**< 受信メッセージのサイズ				*/
+		} wmbf;
+
+		struct S_WMPL {
+			INT		blksz;				/**< メモリブロックサイズ					*/
+			VP		blk;				/**< メモリブロックのアドレス				*/
+		} wmpl;
+
+		struct S_WMPF
+		{
+			VP		blf;				/**< メモリブロックのアドレス				*/
+		} wmpf;
+
+	} wait;
+
+
+
+
+	struct S_TCB	*next;				/**< 次のTCBへのポインタ				*/
+	struct S_TCB	*prev;				/**< 前のTCBへのポインタ				*/
+
+//	PRI				pri;				/**< タスク優先度						*/
+//	VH				sts;				/**< タスク状態フラグ					*/
+
+	VB				dmy[2];				/**< ダミー							*/
+	TMO				tmout;				/**< タイムアウト時刻					*/
+	VB				*arg;				/**< 引数のアドレス					*/
+
+//	FP				sta_func;			/**< スタートアドレス					*/
+//	VB				*end_func;			/**< 終了処理関数のアドレス			*/
+//	VB				*stack;				/**< スタック初期値					*/
+//	VB				*sp;				/**< スタックポインタ					*/
+
+//	PRI				endpri;				/**< 終了処理実行時の優先度			*/
+	UH				susmask;			/**< SUSPEND マスク状態				*/
+//	UH				ipri;				/**< 初期タスク優先度					*/
+//	UB				size;				/**< スタックサイズ(KB)				*/
+//	UB				r_size;				/**< 残りスタックサイズ(%)			*/
+//	UW				*scp;				/**< スタックチェックポイント			*/
+
+
+	/* ここから、このシミュレータ独自の実装 */
+	B				name[16];			/**< タスク名							*/
+
+} T_TCB;
+
+typedef struct S_TCBTMO
+{
+		ID			tskid;				/* タスクID番号						*/
+		PRI			_pri;				/* ダミー							*/
+		VH			sts;				/* タスク状態フラグ					*/
+		ID			_wid;				/* ダミー							*/
+		T_TCB		*next;				/* 次のTCBへのポインタ				*/
+		T_TCB		*prev;				/* 前のTCBへのポインタ				*/
+
+		VH			_wfmode;			/* ダミー							*/
+		VH			_waiptn;			/* ダミー							*/
+		UH			_wupcnt;			/* ダミー							*/
+		UH			_suscnt;			/* ダミー							*/
+		TMO			tmout;				/* タイムアウト時刻					*/
+		T_TCB		*tcb;				/* TCB の本体						*/
+} T_TCBTMO;
+
+/*--------------------------------------------------------------------------*/
+/*                    レディキュー管理ブロック ( RDQ )                      */
+/*--------------------------------------------------------------------------*/
+typedef struct S_RDQ
+{
+	T_LST lst;
+
+	T_TCB *head;
+} T_RDQ;
+
+/* タスクシステムの初期化 */
+int tsk_initialize(void);
+
+/* タスクシステムの終了 */
+void tsk_terminate(void);
+
+ER kernel_cre_tsk(T_TCB *p_tcb);
+
+/* タスクIDを取得する */
+ER kernel_tsk_get_self_tskid(ID *p_tskid);
+
+/* TCBを得る */
+ER tsk_get_tcb(ID tskid, T_TCB** pp_tcb);
+
+/* ディスパッチされるまで待つ */
+/* 引数p_kernel_tcbにNULLを指定すると、ブロックしない */
+void tsk_wait_dispatch(void);
+
+/* タスクスケジューラにディスパッチされるまで待つ */
+void tsk_dispatch(void);
+
+/* 待ちタスクリストに繋がれたタスクの待ち状態を解除する */
+void tsk_wait_delete(T_LST *p_wtsklst);
+
+void tsk_wait_release(T_TCB *p_tcb, ER ercd);
+
+#define	TSK_GET_WTSKID(p_wtsklst) ((BOOL_ID)(lst_empty(p_wtsklst) ? FALSE : ((T_TCB *)(p_wtsklst))->tskid))
+
+ER end_func_set(ID tskid);
+
+
+
+#endif /* _TSK_H_ */