Commit: eefe55010f308d5c8a0604f069e2c96864339927 - OSECPU_VM_2 (git)

Commit MetaInfo

• Revisión: eefe55010f308d5c8a0604f069e2c96864339927 (tree)
• Tiempo: 2014-05-29 02:29:20
• Autor: hikarupsp <hikarupsp@user...>
• Commiter: hikarupsp

Log Message

osecpu106a

Cambiar Resumen

• modified: .gitignore
• modified: Makefile
• add: api.c
• add: bitmemo.txt
• add: driver.c
• modified: extend.c
• modified: float.c
• modified: integer.c
• modified: memo.txt
• modified: osecpu-vm.c
• modified: osecpu-vm.h
• add: other.c
• modified: pointer.c
• modified: test.c

Diferencia incremental

--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 a.out
 make_vm.bat
 osecpu-test.exe
+osecpu-test.bin

--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,7 @@
 CC	= cc
-SRCS	= extend.c float.c integer.c osecpu-vm.c pointer.c test.c
+SRCS	= api.c driver.c extend.c float.c \
+		 integer.c osecpu-vm.c other.c  pointer.c \
+		 test.c
 BINNAME	= osecpu-test.bin
 
 $(BINNAME): $(SRCS)

--- /dev/null
+++ b/api.c
@@ -0,0 +1,76 @@
+#include "osecpu-vm.h"
+#include <setjmp.h>
+
+const Int32 *apiEntry(OsecpuVm *vm);
+
+/* driver.c */
+void *mallocRWE(int bytes); // 実行権付きメモリのmalloc.
+void drv_openWin(int x, int y, unsigned char *buf, char *winClosed);
+void drv_flshWin(int sx, int sy, int x0, int y0);
+void drv_sleep(int msec);
+
+void apiInit(OsecpuVm *vm)
+{
+	vm->p[0x28].typ = PTR_TYP_NATIVECODE;
+	vm->p[0x28].p = (void *) &apiEntry;
+	return;
+}
+
+Int32 apiGetRxx(OsecpuVm *vm, int r, int bit);
+
+void api0001_putString(OsecpuVm *vm);
+void api0002_drawPoint(OsecpuVm *vm);
+void api0003_drawLine(OsecpuVm *vm);
+void api0004_rect(OsecpuVm *vm);
+void api0005_oval(OsecpuVm *vm);
+void api0006_drawString(OsecpuVm *vm);
+void api0008_exit(OsecpuVm *vm);
+void api0009_sleep(OsecpuVm *vm);
+
+const Int32 *apiEntry(OsecpuVm *vm)
+// VMの再開地点を返す.
+{
+	int func = apiGetRxx(vm, 0x30, 16);
+	if (vm->errorCode != 0) goto fin;
+	if (func == 0x0001) { api0001_putString(vm);	goto fin; }
+	if (func == 0x0002) { api0002_drawPoint(vm);	goto fin; }
+	if (func == 0x0003) { api0003_drawLine(vm);		goto fin; }
+	if (func == 0x0004) { api0004_rect(vm);			goto fin; }
+	if (func == 0x0005) { api0005_oval(vm);			goto fin; }
+	if (func == 0x0006) { api0006_drawString(vm);	goto fin; }
+	if (func == 0x0008) { api0008_exit(vm);			goto fin; }
+	if (func == 0x0009) { api0009_sleep(vm);		goto fin; }
+	jitcSetRetCode(&vm->errorCode, EXEC_API_ERROR);
+fin: ;
+	const Int32 *retcode = NULL;
+	execStep_checkMemAccess(vm, 0x30, PTR_TYP_CODE, EXEC_CMA_FLAG_EXEC); // 主にliveSignのチェック.
+	if (vm->errorCode == 0)
+		retcode = (const Int32 *) vm->p[0x30].p;
+	return retcode;
+}
+
+Int32 apiGetRxx(OsecpuVm *vm, int r, int bit)
+{
+	Int32 i, value = vm->r[r];
+	if (vm->bit[r] != BIT_DISABLE_REG && vm->bit[r] < bit)
+		jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
+	i = (-1) << bit;
+	if ((value & (1 << (bit - 1))) == 0) {
+		// 符号ビットが0だった.
+		value &= ~i;
+	} else {
+		// 符号ビットが1だった.
+		value |=  i;
+	}
+	return value;
+}
+
+void api0001_putString(OsecpuVm *vm) { }
+void api0002_drawPoint(OsecpuVm *vm) { }
+void api0003_drawLine(OsecpuVm *vm) { }
+void api0004_rect(OsecpuVm *vm) { puts("api0004_rect");  }
+void api0005_oval(OsecpuVm *vm) { }
+void api0006_drawString(OsecpuVm *vm) { }
+void api0008_exit(OsecpuVm *vm) { }
+void api0009_sleep(OsecpuVm *vm) { }
+

--- /dev/null
+++ b/bitmemo.txt
@@ -0,0 +1,56 @@
+bit[]に関するメモ
+
+#1. 目的
+整数演算に関するbitは、多倍長演算において、どの精度まで行えば結果が変わらないのかをVMに教えるための手段である。
+したがって、bit=32であってもVMは64ビット演算をするかもしれないし、256ビット演算をするかもしれない。
+しかしそれによって、最終的な結果が少しでも変わることは許さない。
+この情報があればVM（特にJITコンパイラ）は、処理を高速化できる。
+
+#2. 注意すべき点
+レジスタやメモリのbitの情報は、高速モードでは一切生成されない。参照もされない。
+あるタスクがあって、それは最初安全モードで動作していたとする。それが一度高速モードに切り替わって、また安全モードに
+戻ったとしても、結果は正しく得られなければならない。高速モード中に情報が失われているので、チェック能力が下がるのは
+かまわない。
+つまりbitに依存した動作をすることは許されない。
+
+#3. タスクセーブに関すること
+タスクセーブでは、不定ビットは全て0か1に初期化される。と思ったが、これは必要ないかもしれない。
+なぜなら高速モードではbitがないので、この不定ビットつぶしができない。つまり他のタスクからの情報が流出しうる。
+となれば、やはり消すのは別のところでやるべきだ。malloc時に重要であると明示させるのがよさそう。
+そうすればVMもしくはOSは、free時にゼロクリアできる。
+同じ問題はレジスタでも起こり得る。だから重要な値を持つレジスタは明示的にデータを消さなければいけない。
+その際には必要なビット幅でLIMMをするべき。その後にbit=0のLIMMをしてもしなくてもいい。
+これは2度手間だけど、使用頻度を考えれば妥当。
+
+#4. VMは安全モードの場合は、不定ビットをレジスタ内に残さず、常に符号拡張した状態で処理する。
+これは値の範囲チェックをするため。高速モードでは、不定ビットを残していてもよい。
+タスクセーブ時には、不定ビットは殺してしまう。
+しかしこの方法では、高速モードから安全モードに移行した際に問題にならないか？
+高速モードではどこまでビットをつぶすべきか分かっていないのだから。
+さてこまった。となると、高速モードから安全モードに戻せないとしたほうがいいのかもしれない。
+もしくはbitに不明という状態を許すか？不明の間は、しょうがないのでチェックができない。
+分かったらすぐにチェックをする。まあこれもありかもしれない。・・・よしこれにしよう。
+
+#5. LMEM
+
+
+
+#6. SMEM
+(1)SINT32のメモリに対して、bit=16のデータを書き込むことは許される。
+  その場合、メモリのbitは16になる。書いた値が読み出せるかどうかのチェックはない。
+(2)UINT32のメモリに対して、bit=16のデータを書き込むことは許される。
+  その場合、メモリのbitは16になる。書いた値が読み出せるかどうかのチェックは少しある。
+    それはデータが負ではないこと。負はどうやっても読み出せないから。
+dat.bit=min(reg.bit, SMEM.bit)
+(3)typ.bit >= dat.bit は原則OK。ただし、符号のチェックはある。
+  unsignedなtypで、reg<0ならダメ。
+(4)typ.bit < dat.bit の場合は、値の範囲が妥当なら問題ない。範囲がまずければやはりエラーになる。
+(5)2F-0がある場合は、ダメな場合でもメモリのbitが0になるだけで、アプリは例外を起こさずに続行できる。
+  しかしそれでも符号のチェックはある。
+(6)2F-0でUINT系を全部エラーにしてしまえばいいかとも思ったけど、レジスタの用法はわからないので、
+  将来のアプリに配慮した。
+
+#7. LMEM, SMEMのプリフィクス
+2F-0: マスクリード、マスクライト。
+2F-1: レジスタ退避用のリードライト。
+2F-2: メモリのbitを0にする。

--- /dev/null
+++ b/driver.c
@@ -0,0 +1,526 @@
+/* OS依存関数 */
+void *mallocRWE(int bytes); // 実行権付きメモリのmalloc.
+void drv_openWin(int x, int y, unsigned char *buf, char *winClosed);
+void drv_flshWin(int sx, int sy, int x0, int y0);
+void drv_sleep(int msec);
+
+#if (!defined(JITC_OSNUM))
+	#if (defined(_WIN32))
+		#define JITC_OSNUM			0x0001
+	#endif
+	#if (defined(__APPLE__))
+		#define JITC_OSNUM			0x0002
+	#endif
+	#if (defined(__linux__))
+		#define JITC_OSNUM			0x0003
+	#endif
+	/* 0001: win32-x86-32bit */
+	/* 0002: MacOS-x86-32bit */
+	/* 0003: linux-x86-32bit */
+#endif
+
+/* OS依存部 */
+
+#if (DRV_OSNUM == 0x0001)
+
+#include <windows.h>
+#include <setjmp.h>
+
+#define TIMER_ID			 1
+#define TIMER_INTERVAL		10
+
+struct BLD_WORK {
+	HINSTANCE hi;
+	HWND hw;
+	BITMAPINFO bmi;
+	int tmcount1, tmcount2, flags, smp; /* bit0: 終了 */
+	HANDLE mtx;
+	char *winClosed;
+};
+
+struct BLD_WORK bld_work;
+
+struct BL_WIN {
+	int xsiz, ysiz, *buf;
+};
+
+struct BL_WORK {
+	struct BL_WIN win;
+	jmp_buf jb;
+	int csiz_x, csiz_y, cx, cy, col0, col1, tabsiz, slctwin;
+	int tmcount, tmcount0, mod, rand_seed;
+	int *cbuf;
+	unsigned char *ftyp;
+	unsigned char **fptn;
+	int *ccol, *cbak;
+	int *kbuf, kbuf_rp, kbuf_wp, kbuf_c;
+};
+
+struct BL_WORK bl_work;
+
+#define BL_SIZ_KBUF			8192
+
+#define BL_WAITKEYF		0x00000001
+#define BL_WAITKEYNF	0x00000002
+#define BL_WAITKEY		0x00000003
+#define BL_GETKEY		0x00000004
+#define BL_CLEARREP		0x00000008
+#define BL_DELFFF		0x00000010
+
+#define	BL_KEYMODE		0x00000000	// 作りかけ, make/remake/breakが見えるかどうか
+
+#define w	bl_work
+#define dw	bld_work
+
+void bld_openWin(int x, int y, char *winClosed);
+void bld_flshWin(int sx, int sy, int x0, int y0);
+LRESULT CALLBACK WndProc(HWND hw, unsigned int msg, WPARAM wp, LPARAM lp);
+void bl_cls();
+int bl_iCol(int i);
+void bl_readyWin(int n);
+
+static HANDLE threadhandle;
+
+int main(int argc, const UCHAR **argv)
+{
+	return OsecpuMain(argc, argv);
+}
+
+void *mallocRWE(int bytes)
+{
+	void *p = malloc(bytes);
+	DWORD dmy;
+	VirtualProtect(p, bytes, PAGE_EXECUTE_READWRITE, &dmy);
+	return p;
+}
+
+static int winthread(void *dmy)
+{
+	WNDCLASSEX wc;
+	RECT r;
+	unsigned char *p, *p0, *p00;
+	int i, x, y;
+	MSG msg;
+
+	x = dw.bmi.bmiHeader.biWidth;
+	y = - dw.bmi.bmiHeader.biHeight;
+
+	wc.cbSize = sizeof (WNDCLASSEX);
+	wc.style = CS_HREDRAW | CS_VREDRAW;
+	wc.lpfnWndProc = WndProc;
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 0;
+	wc.hInstance = dw.hi;
+	wc.hIcon = (HICON) LoadImage(NULL, MAKEINTRESOURCE(IDI_APPLICATION),
+		IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
+	wc.hIconSm = wc.hIcon;
+	wc.hCursor = (HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(IDC_ARROW),
+		IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
+	wc.hbrBackground = (HBRUSH) COLOR_APPWORKSPACE;
+	wc.lpszMenuName = NULL;
+	wc.lpszClassName = "WinClass";
+	if (RegisterClassEx(&wc) == 0)
+		return 1;
+	r.left = 0;
+	r.top = 0;
+	r.right = x;
+	r.bottom = y;
+	AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
+	x = r.right - r.left;
+	y = r.bottom - r.top;
+
+#if 0
+	static unsigned char t[32];
+	p00 = p0 = p = GetCommandLineA();
+	if (*p == 0x22) {
+		p00 = p0 = ++p;
+		while (*p != '\0' && *p != 0x22) {
+			if (*p == '\\')
+				p0 = p + 1;
+			p++;
+		}
+	} else {
+		while (*p > ' ') {
+			if (*p == '\\')
+				p0 = p + 1;
+			p++;
+		}
+	}
+	if (p - p0 > 4 && p[-4] == '.' && p[-3] == 'e' && p[-2] == 'x' && p[-1] == 'e')
+		p -= 4;
+	for (i = 0; i < 32 - 1; i++) {
+		if (p <= &p0[i])
+			break;
+		t[i] = p0[i];
+	}
+	t[i] = '\0';
+#endif
+	char *t = "osecpu";
+
+	dw.hw = CreateWindowA(wc.lpszClassName, t, WS_OVERLAPPEDWINDOW,
+		CW_USEDEFAULT, CW_USEDEFAULT, x, y, NULL, NULL,	dw.hi, NULL);
+	if (dw.hw == NULL)
+		return 1;
+	ShowWindow(dw.hw, SW_SHOW);
+	UpdateWindow(dw.hw);
+	SetTimer(dw.hw, TIMER_ID,     TIMER_INTERVAL,       NULL);
+	SetTimer(dw.hw, TIMER_ID + 1, TIMER_INTERVAL * 10,  NULL);
+	SetTimer(dw.hw, TIMER_ID + 2, TIMER_INTERVAL * 100, NULL);
+	dw.flags |= 2 | 4;
+
+	for (;;) {
+		i = GetMessage(&msg, NULL, 0, 0);
+		if (i == 0 || i == -1)	/* エラーもしくは終了メッセージ */
+			break;
+		/* そのほかはとりあえずデフォルト処理で */
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+//	PostQuitMessage(0);
+	dw.flags |= 1; /* 終了, bld_waitNF()が見つける */
+	if (dw.winClosed != NULL)
+		*dw.winClosed = 1;
+	return 0;
+}
+
+void bld_openWin(int sx, int sy, char *winClosed)
+{
+	static int i;
+
+	dw.bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
+	dw.bmi.bmiHeader.biWidth = sx;
+	dw.bmi.bmiHeader.biHeight = - sy;
+	dw.bmi.bmiHeader.biPlanes = 1;
+	dw.bmi.bmiHeader.biBitCount = 32;
+	dw.bmi.bmiHeader.biCompression = BI_RGB;
+	dw.winClosed = winClosed;
+
+	threadhandle = CreateThread(NULL, 0, (void *) &winthread, NULL, 0, (void *) &i);
+
+	return;
+}
+
+void drv_flshWin(int sx, int sy, int x0, int y0)
+{
+	InvalidateRect(dw.hw, NULL, FALSE);
+	UpdateWindow(dw.hw);
+	return;
+}
+
+LRESULT CALLBACK WndProc(HWND hw, unsigned int msg, WPARAM wp, LPARAM lp)
+{
+	int i, j;
+	if (msg == WM_PAINT) {
+		PAINTSTRUCT ps;
+		HDC hdc = BeginPaint(dw.hw, &ps);
+		SetDIBitsToDevice(hdc, 0, 0, w.win.xsiz, w.win.ysiz,
+			0, 0, 0, w.win.ysiz, w.win.buf, &dw.bmi, DIB_RGB_COLORS);
+		EndPaint(dw.hw, &ps);
+	}
+	if (msg == WM_DESTROY) {
+		PostQuitMessage(0);
+		return 0;
+	}
+	if (msg == WM_TIMER && wp == TIMER_ID) {
+		w.tmcount += TIMER_INTERVAL;
+		return 0;
+	}
+	if (msg == WM_TIMER && wp == TIMER_ID + 1) {
+		dw.tmcount1 += TIMER_INTERVAL * 10;
+		w.tmcount = dw.tmcount1;
+		return 0;
+	}
+	if (msg == WM_TIMER && wp == TIMER_ID + 2) {
+		dw.tmcount2 += TIMER_INTERVAL * 100;
+		w.tmcount = dw.tmcount1 = dw.tmcount2;
+		return 0;
+	}
+	if (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN) {
+		i = -1;
+#if 0
+		int s_sht = GetKeyState(VK_SHIFT);
+		int s_ctl = GetKeyState(VK_CONTROL);
+		int s_cap = GetKeyState(VK_CAPITAL);
+		int s_num = GetKeyState(VK_NUMLOCK);
+		if ('A' <= wp && wp <= 'Z') {
+			i = wp;
+			if (((s_sht < 0) ^ (s_cap & 1)) == 0)
+				i += 'a' - 'A';
+		}
+		if (wp == VK_SPACE)		i = ' ';
+#endif
+		if (wp == VK_RETURN)	i = KEY_ENTER;
+		if (wp == VK_ESCAPE)	i = KEY_ESC;
+		if (wp == VK_BACK)		i = KEY_BACKSPACE;
+		if (wp == VK_TAB)		i = KEY_TAB;
+		if (wp == VK_PRIOR)		i = KEY_PAGEUP;
+		if (wp == VK_NEXT)		i = KEY_PAGEDWN;
+		if (wp == VK_END)		i = KEY_END;
+		if (wp == VK_HOME)		i = KEY_HOME;
+		if (wp == VK_LEFT)		i = KEY_LEFT;
+		if (wp == VK_RIGHT)		i = KEY_RIGHT;
+		if (wp == VK_UP)		i = KEY_UP;
+		if (wp == VK_DOWN)		i = KEY_DOWN;
+		if (wp == VK_INSERT)	i = KEY_INS;
+		if (wp == VK_DELETE)	i = KEY_DEL;
+		j &= 0;
+		if ((GetKeyState(VK_LCONTROL) & (1 << 15)) != 0) j |= 1 << 17;
+		if ((GetKeyState(VK_LMENU)    & (1 << 15)) != 0) j |= 1 << 18;
+		if ((GetKeyState(VK_RCONTROL) & (1 << 15)) != 0) j |= 1 << 25;
+		if ((GetKeyState(VK_RMENU)    & (1 << 15)) != 0) j |= 1 << 26;
+		if ((GetKeyState(VK_RSHIFT)   & (1 << 15)) != 0) i |= 1 << 24;
+		if ((GetKeyState(VK_LSHIFT)   & (1 << 15)) != 0) i |= 1 << 16;
+		if ((GetKeyState(VK_NUMLOCK)  & (1 <<  0)) != 0) i |= 1 << 22;
+		if ((GetKeyState(VK_CAPITAL)  & (1 <<  0)) != 0) i |= 1 << 23;
+		if (j != 0) {
+			if ('A' <= wp && wp <= 'Z') i = wp;
+		}
+		if (i != -1) {
+			putKeybuf(i | j);
+//			bl_putKeyB(1, &i);
+			return 0;
+		}
+	}
+	if (msg == WM_KEYUP) {
+		i = 0xfff;
+//		bl_putKeyB(1, &i);
+	}
+	if (msg == WM_CHAR) {
+		i = 0;
+		if (' ' <= wp && wp <= 0x7e) {
+			i = wp;
+			j &= 0;
+			if ((GetKeyState(VK_LCONTROL) & (1 << 15)) != 0) j |= 1 << 17;
+			if ((GetKeyState(VK_LMENU)    & (1 << 15)) != 0) j |= 1 << 18;
+			if ((GetKeyState(VK_RCONTROL) & (1 << 15)) != 0) j |= 1 << 25;
+			if ((GetKeyState(VK_RMENU)    & (1 << 15)) != 0) j |= 1 << 26;
+			if ((GetKeyState(VK_RSHIFT)   & (1 << 15)) != 0) i |= 1 << 24;
+			if ((GetKeyState(VK_LSHIFT)   & (1 << 15)) != 0) i |= 1 << 16;
+			if ((GetKeyState(VK_NUMLOCK)  & (1 <<  0)) != 0) i |= 1 << 22;
+			if ((GetKeyState(VK_CAPITAL)  & (1 <<  0)) != 0) i |= 1 << 23;
+			if (('A' <= wp && wp <= 'Z') || ('a' <= wp && wp <= 'z')) {
+				if (j != 0) {
+					i |= j;
+					i &= ~0x20;
+				}
+			}
+			putKeybuf(i);
+//			bl_putKeyB(1, &i);
+			return 0;
+		}
+	}
+	return DefWindowProc(hw, msg, wp, lp);
+}
+
+void drv_openWin(int sx, int sy, UCHAR *buf, char *winClosed)
+{
+	int i, x, y;
+//	if (sx <= 0 || sy <= 0) return;
+//	if (sx < 160) return;
+	w.win.buf = (int *) buf;
+	w.win.xsiz = sx;
+	w.win.ysiz = sy;
+	bld_openWin(sx, sy, winClosed);
+	return;
+}
+
+void drv_sleep(int msec)
+{
+	Sleep(msec);
+//	MsgWaitForMultipleObjects(1, &threadhandle, FALSE, msec, QS_ALLINPUT);
+	/* 勉強不足でまだ書き方が分かりません! */
+	return;
+}
+
+#endif
+
+#if (DRV_OSNUM == 0x0002)
+
+// by Liva, 2013.05.29-
+
+#include <mach/mach.h>
+#include <Cocoa/Cocoa.h>
+
+void *mallocRWE(int bytes)
+{
+	void *p = malloc(bytes);
+	vm_protect(mach_task_self(), (vm_address_t) p, bytes, FALSE, VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE);
+	return p;
+}
+
+NSApplication* app;
+
+@interface OSECPUView : NSView {
+  UCHAR *_buf;
+  int _sx;
+  int _sy;
+	CGContextRef _context;
+}
+
+- (id)initWithFrame:(NSRect)frameRect
+  buf : (UCHAR *) buf
+  sx : (int) sx
+  sy : (int) sy;
+
+- (void)drawRect:(NSRect)rect;
+@end
+
+@implementation OSECPUView
+- (id)initWithFrame:(NSRect)frameRect
+  buf : (UCHAR *) buf
+  sx : (int) sx
+  sy : (int) sy
+{
+  self = [super initWithFrame:frameRect];
+  if (self) {
+    _buf = buf;
+    _sx = sx;
+    _sy = sy;
+  }
+  return self;
+}
+ 
+- (void)drawRect:(NSRect)rect {
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  _context = CGBitmapContextCreate (_buf, _sx, _sy, 8, 4 * _sx, colorSpace, (kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst));
+  CGImageRef image = CGBitmapContextCreateImage(_context);
+  CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
+  CGContextDrawImage(currentContext, NSRectToCGRect(rect), image);
+}
+ 
+@end
+
+@interface Main : NSObject<NSWindowDelegate> {
+  int argc;
+  const UCHAR **argv;
+  char *winClosed;
+  OSECPUView *_view;
+}
+
+- (void)runApp;
+- (void)createThread : (int)_argc
+args : (const UCHAR **)_argv;
+- (BOOL)windowShouldClose:(id)sender;
+- (void)openWin : (UCHAR *)buf
+sx : (int) sx
+sy : (int) sy
+winClosed : (char *)_winClosed;
+- (void)flushWin : (NSRect) rect;
+@end
+
+@implementation Main
+- (void)runApp
+{
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  OsecpuMain(argc,argv);
+  [NSApp terminate:self];
+	[pool release];
+}
+
+- (void)createThread : (int)_argc
+  args : (const UCHAR **)_argv
+{
+  argc = _argc;
+  argv = _argv;
+  NSThread *thread = [[[NSThread alloc] initWithTarget:self selector:@selector(runApp) object:nil] autorelease];
+  [thread start];
+}
+
+- (BOOL)windowShouldClose:(id)sender
+{
+  *winClosed = 1;
+  return YES;
+}
+
+- (void)openWin : (UCHAR *)buf
+  sx : (int) sx
+  sy : (int) sy
+  winClosed : (char *)_winClosed
+{
+
+	NSWindow* window = [[NSWindow alloc] initWithContentRect: NSMakeRect(0, 0, sx, sy) styleMask: NSTitledWindowMask | NSMiniaturizableWindowMask | NSClosableWindowMask backing: NSBackingStoreBuffered defer: NO];
+	[window setTitle: @"osecpu"];
+	[window center];
+	[window makeKeyAndOrderFront:nil];
+	[window setReleasedWhenClosed:YES];
+	window.delegate = self;
+	winClosed = _winClosed;
+
+	_view = [[OSECPUView alloc] initWithFrame:NSMakeRect(0,0,sx,sy) buf:buf sx:sx sy:sy];
+	[window.contentView addSubview:_view];
+}
+
+- (void)flushWin : (NSRect) rect
+  {
+    [_view drawRect:rect];
+  }
+
+@end
+
+id objc_main;
+
+int main(int argc, const UCHAR **argv)
+{
+  objc_main = [[Main alloc] init];
+  
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  app = [[NSApplication alloc] init];
+  [objc_main createThread:argc args:argv];
+  [app run];
+	[pool release];
+  return 0;
+}
+
+void drv_openWin(int sx, int sy, UCHAR *buf, char *winClosed)
+{
+  [objc_main openWin:buf sx:sx sy:sy winClosed:winClosed];
+}
+
+void drv_flshWin(int sx, int sy, int x0, int y0)
+{
+  [objc_main flushWin:NSMakeRect(x0,y0,sx,sy)];
+}
+
+void drv_sleep(int msec)
+{
+  [NSThread sleepForTimeInterval:0.001*msec];
+   return;
+}
+
+#endif
+
+#if (DRV_OSNUM == 0x0003)
+ 
+// by takeutch-kemeco, 2013.07.25-
+ 
+// gcc -D__linux__ osecpu.c `pkg-config blike --cflags --libs` -o osecpu
+ 
+ 
+void __bl_openWin_attach_vram(int, int, int*);
+void *__bld_mallocRWE(unsigned int);
+void bld_flshWin(int, int, int, int);
+void bl_wait(int);
+void __bld_set_callback_key_press(void (*f)(void*, const int));
+void __bld_set_callback_key_release(void (*f)(void*, const int));
+ 
+extern int bl_argc;
+extern const UCHAR** bl_argv;
+ 
+static void __drv_bld_callback_key_press(void* a, const int keyval) { if (keyval != -1) putKeybuf(keyval); }
+static void __drv_bld_callback_key_release(void* a, const int keyval) { /* putKeybuf(0x0fff); */ }
+ 
+void *mallocRWE(int bytes) { return __bld_mallocRWE(bytes); }
+void drv_openWin(int sx, int sy, UCHAR *buf, char *winClosed) { __bl_openWin_attach_vram(sx, sy, (int*) buf); }
+void drv_flshWin(int sx, int sy, int x0, int y0) { bld_flshWin(sx, sy, x0, y0); }
+void drv_sleep(int msec) { bl_wait(msec); }
+ 
+blMain()
+{
+    __bld_set_callback_key_press(__drv_bld_callback_key_press);
+    __bld_set_callback_key_release(__drv_bld_callback_key_release);
+    OsecpuMain(bl_argc, bl_argv);
+}
+ 
+#endif /* (DRV_OSNUM == 0x0003) */
+
+

--- a/extend.c
+++ b/extend.c
@@ -12,9 +12,9 @@ int jitcStepExtend(OsecpuJitc *jitc)
 	return -1;
 }
 
-void jitcAfterStepExtend(OsecpuJitc *jitc)
+int jitcAfterStepExtend(OsecpuJitc *jitc)
 {
-	return;
+	return 0;
 }
 
 void execStepExtend(OsecpuVm *vm)

--- a/float.c
+++ b/float.c
@@ -95,6 +95,7 @@ int jitcStepFloat(OsecpuJitc *jitc)
 		jitcStep_checkFxx(pRC, f);
 		jitcStep_checkBits32(pRC, bit0);
 		jitcStep_checkRxxNotR3F(pRC, r);
+		jitc->prefix2f[0] = 0; // 2F-0.
 		goto fin;
 	}
 	if (0x48 <= opecode && opecode <= 0x4d) {
@@ -125,9 +126,9 @@ fin1:
 	return retcode;
 }
 
-void jitcAfterStepFloat(OsecpuJitc *jitc)
+int jitcAfterStepFloat(OsecpuJitc *jitc)
 {
-	return;
+	return 0;
 }
 
 void execStepFloat(OsecpuVm *vm)
@@ -200,7 +201,7 @@ void execStepFloat(OsecpuVm *vm)
 		}
 		vm->r[r] = (Int32) vm->f[f];
 		vm->bit[r] = bit0;
-		execStep_checkBitsRange(vm->r[r], bit0, vm);
+		vm->r[r] = execStep_checkBitsRange(vm->r[r], bit0, vm, 0, 0);
 		ip += 5;
 		goto fin;
 	}

--- a/integer.c
+++ b/integer.c
@@ -1,6 +1,37 @@
 #include "osecpu-vm.h"
 
-// 整数命令: 02, 10-16, 18-1B, 20-27, FD
+// 整数命令: 02, 08-09, 10-16, 18-1B, 20-27, 2F, FD
+
+int getTypBitInteger(int typ)
+{
+	int retcode = 0;
+	if (2 <= typ && typ <= 21) {
+		static unsigned char table[10] = { 8, 16, 32, 4, 2, 1, 12, 20, 24, 28 };
+		retcode = table[(typ - 2) / 2];
+	}
+	return retcode;
+}
+
+void getTypInfoInteger(int typ, int *typSize0, int *typSize1, int *typSign)
+// typSize0: 公式サイズ(ビット単位).
+// typSize1: 内部サイズ(バイト単位).
+// typSign:  符号の有無(0は符号なし).
+{
+	*typSize0 = *typSize1 = -1;
+	if (2 <= typ && typ <= 21) {
+		int bytes;
+		if ((typ & 1) == 0)
+			*typSign = -1; // typが偶数なら符号あり.
+		else
+			*typSign = 0; // typが奇数なら符号なし.
+		*typSize0 = getTypBitInteger(typ);
+		bytes = (*typSize0 + 7) / 8;
+		if (bytes == 3) bytes = 4;
+		*typSize1 = bytes;
+	}
+	return;
+}
+
 
 void jitcInitInteger(OsecpuJitc *jitc)
 {
@@ -12,13 +43,9 @@ int jitcStepInteger(OsecpuJitc *jitc)
 {
 	Int32 *ip = jitc->hh4Buffer;
 	Int32 opecode = ip[0], imm;
-	int bit, bit0, bit1, r, r0, r1, r2;
+	int bit, bit0, bit1, r, r0, r1, r2, p, typ;
 	int retcode = -1, *pRC = &retcode;
-	int i;
-	if (opecode == 0x00) { /* NOP */
-		jitcSetHh4BufferSimple(jitc, 1);
-		goto fin;
-	}
+	int i, j;
 	if (opecode == 0x02) { /* LIMM(imm, Rxx, bits); */
 		ip[1] = hh4ReaderGetSigned(&jitc->hh4r);
 		ip[2] = hh4ReaderGetUnsigned(&jitc->hh4r);
@@ -42,6 +69,43 @@ int jitcStepInteger(OsecpuJitc *jitc)
 		jitc->ope04 = jitc->dst;
 		goto fin;
 	}
+	if (opecode == 0x08) {	/* LMEM(p, typ, 0, r, bit); */
+		jitcSetHh4BufferSimple(jitc, 6);
+		p = ip[1]; typ = ip[2]; i = ip[3]; r = ip[4]; bit = ip[5];
+		if (i != 0) {
+			jitcSetRetCode(pRC, JITC_UNSUPPORTED);
+			goto fin;
+		}
+		jitcStep_checkPxx(pRC, p);
+		jitcStep_checkRxxNotR3F(pRC, r);
+		jitcStep_checkBits32(pRC, bit);
+		if (jitc->prefix2f[0] != 0 && jitc->prefix2f[1] != 0)
+			jitcSetRetCode(pRC, JITC_BAD_PREFIX);	// 2F-n系プリフィクスは1個まで.
+		jitc->prefix2f[0] = 0; // 2F-0.
+		jitc->prefix2f[1] = 0; // 2F-1.
+		goto fin;
+	}
+	if (opecode == 0x09) {	/* SMEM(r, bit, p, typ, 0); */
+		jitcSetHh4BufferSimple(jitc, 6);
+		r = ip[1]; bit = ip[2]; p = ip[3]; typ = ip[4]; i = ip[5];
+		if (i != 0) {
+			jitcSetRetCode(pRC, JITC_UNSUPPORTED);
+			goto fin;
+		}
+		jitcStep_checkPxx(pRC, p);
+		jitcStep_checkRxxNotR3F(pRC, r);
+		j = 0;
+		for (i = 0; i < 3; i++) {
+			if (jitc->prefix2f[i] != 0)
+				j++;
+		}
+		if (j > 1)
+			jitcSetRetCode(pRC, JITC_BAD_PREFIX);	// 2F-n系プリフィクスは1個まで.
+		jitc->prefix2f[0] = 0; // 2F-0.
+		jitc->prefix2f[1] = 0; // 2F-1.
+		jitc->prefix2f[2] = 0; // 2F-2.
+		goto fin;
+	}
 	if (0x10 <= opecode && opecode <= 0x1b && opecode != 0x13 && opecode != 0x17) {
 		jitcSetHh4BufferSimple(jitc, 5);
 		r1 = ip[1]; r2 = ip[2]; r0 = ip[3]; bit = ip[4];
@@ -49,6 +113,7 @@ int jitcStepInteger(OsecpuJitc *jitc)
 		jitcStep_checkRxx(pRC, r2);
 		jitcStep_checkRxxNotR3F(pRC, r0);
 		jitcStep_checkBits32(pRC, bit);
+		jitc->prefix2f[0] = 0; // 2F-0.
 		goto fin;
 	}
 	if (opecode == 0x13) {	// SBX.
@@ -59,6 +124,7 @@ int jitcStepInteger(OsecpuJitc *jitc)
 		if (r2 != 0x3f)
 			jitcSetRetCode(pRC, JITC_BAD_RXX);
 		jitcStep_checkBits32(pRC, bit);
+		jitc->prefix2f[0] = 0; // 2F-0.
 		goto fin;
 	}
 	if (0x20 <= opecode && opecode <= 0x27) {
@@ -71,13 +137,6 @@ int jitcStepInteger(OsecpuJitc *jitc)
 		jitcStep_checkBits32(pRC, bit1);
 		goto fin;
 	}
-	if (opecode == 0xfd) {
-		jitcSetHh4BufferSimple(jitc, 3);
-		imm = ip[1]; r = ip[2];
- 		if (0 <= r && r <= 3)
-			jitc->dr[r] = imm;
-		goto fin;
-	}
 	goto fin1;
 fin:
 	if (retcode == -1)
@@ -86,46 +145,120 @@ fin1:
 	return retcode;
 }
 
-void jitcAfterStepInteger(OsecpuJitc *jitc)
+int jitcAfterStepInteger(OsecpuJitc *jitc)
 {
+	int i, retcode = 0;
 	if (jitc->ope04 != NULL && jitc->dst != jitc->ope04) {
 		// CND命令の直後の命令を検出.
 		Int32 *dst04 = jitc->ope04;
 		dst04[2] = jitc->instrLength; // 直後の命令の命令長.
 		jitc->ope04 = NULL;
 	}
-	return;
+	return 0;
+}
+
+Int32 execStep_checkBitsRange(Int32 value, int bit, OsecpuVm *vm, int bit1, int bit2)
+{
+	int max, min, i;
+	if (bit1 != BIT_DISABLE_REG && bit2 != BIT_DISABLE_REG && vm->prefix2f[0] == 0) {
+		max = 1 << (bit - 1); // 例: bits=8だとmax=128になる.
+		max--; // 例: bits=8だとmax=127になる.
+		min = - max - 1; // 例: bits=8だとmin=-128になる。
+		if (!(min <= value && value <= max))
+			jitcSetRetCode(&vm->errorCode, EXEC_BITS_RANGE_OVER);
+	} else {
+		vm->prefix2f[0] = 0;
+		if (bit > 0) {
+			i = (-1) << bit;
+			if ((value & (1 << (bit - 1))) == 0) {
+				// 符号ビットが0だった.
+				value &= ~i;
+			} else {
+				// 符号ビットが1だった.
+				value |=  i;
+			}
+		} else
+			value = 0;
+	}
+	return value;
 }
 
 void execStepInteger(OsecpuVm *vm)
 {
 	const Int32 *ip = vm->ip;
 	Int32 opecode = ip[0], imm;
-	int bit, bit0, bit1, r, r0, r1, r2;
-	int i;
-	if (opecode == 0x00) { // NOP();
-		ip++;
-		goto fin;
-	}
+	int bit, bit0, bit1, r, r0, r1, r2, p, typ, typSign, typSize0, typSize1;
+	int i, mbit, tbit;
 	if (opecode == 0x02) { // LIMM(imm, Rxx, bits);
 		imm = ip[1]; r = ip[2]; bit = ip[3]; 
 		vm->r[r] = imm;
 		vm->bit[r] = bit;
-		execStep_checkBitsRange(vm->r[r], bit, vm);
+		execStep_checkBitsRange(vm->r[r], bit, vm, 0, 0);
 		ip += 4;
 		goto fin;
 	}
 	if (opecode == 0x04) { /* CND(Rxx); */
-		r = ip[1];
-		i = ip[2];
+		r = ip[1]; i = ip[2];
 		ip += 3;
 		if ((vm->r[r] & 1) == 0)
 			ip += i;
 		goto fin;
 	}
+	if (opecode == 0x08) {	/* LMEM(p, typ, 0, r, bit); */
+		p = ip[1]; typ = ip[2]; r = ip[4]; bit = ip[5];
+		execStep_checkMemAccess(vm, p, typ, EXEC_CMA_FLAG_READ);
+		if (vm->errorCode != 0) goto fin;
+		mbit = *(vm->p[p].bit);
+		tbit = getTypBitInteger(typ);
+		if (mbit == BIT_DISABLE_MEM)
+			tbit = mbit;
+		getTypInfoInteger(typ, &typSize0, &typSize1, &typSign);
+		if (typSize1 == 1 && typSign == 0) {
+			unsigned char *puc = (unsigned char *) vm->p[p].p;
+			vm->r[r] = *puc;
+		}
+		if (typSize1 == 1 && typSign != 0) {
+			signed char *psc = (signed char *) vm->p[p].p;
+			vm->r[r] = *psc;
+		}
+		if (typSize1 == 2 && typSign == 0) {
+			unsigned short *pus = (unsigned short *) vm->p[p].p;
+			vm->r[r] = *pus;
+		}
+		if (typSize1 == 2 && typSign != 0) {
+			signed short *pss = (signed short *) vm->p[p].p;
+			vm->r[r] = *pss;
+		}
+		if (typSize1 == 4 && typSign == 0) {
+			unsigned int *pui = (unsigned int *) vm->p[p].p;
+			vm->r[r] = *pui;
+		}
+		if (typSize1 == 4 && typSign != 0) {
+			signed int *psi = (signed int *) vm->p[p].p;
+			vm->r[r] = *psi;
+		}
+		if (vm->prefix2f[1] == 0) {
+			if (mbit < tbit && mbit < bit)
+				jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);	// 不確定ビットの参照がある場合.
+		} else {
+			if (bit > mbit)
+				bit = mbit;
+			vm->prefix2f[1] = 0;
+		}
+		vm->bit[r] = bit;
+		if (tbit > bit)
+			vm->r[r] = execStep_checkBitsRange(vm->r[r], bit, vm, 0, 0); // 部分リードの場合は、ゴミビットを消す.
+		ip += 6;
+		goto fin;
+	}
+
 	if (0x10 <= opecode && opecode <= 0x16 && opecode != 0x13) {
 		r1 = ip[1]; r2 = ip[2]; r0 = ip[3]; bit = ip[4];
-		if (bit > vm->bit[r1] || bit > vm->bit[r2]) {
+		if (vm->bit[r1] != BIT_DISABLE_REG && bit > vm->bit[r1]) {
+			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
+			goto fin;
+		}
+		if (vm->bit[r2] != BIT_DISABLE_REG && bit > vm->bit[r2]) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
 			goto fin;
 		}
@@ -136,13 +269,13 @@ void execStepInteger(OsecpuVm *vm)
 		if (opecode == 0x15) vm->r[r0] = vm->r[r1] - vm->r[r2]; // SUB(r0, r1, r2, bits);
 		if (opecode == 0x16) vm->r[r0] = vm->r[r1] * vm->r[r2]; // MUL(r0, r1, r2, bits);
 		vm->bit[r0] = bit;
-		execStep_checkBitsRange(vm->r[r0], bit, vm);
+		vm->r[r0] = execStep_checkBitsRange(vm->r[r0], bit, vm, vm->bit[r1], vm->bit[r2]);
 		ip += 5;
 		goto fin;
 	}
 	if (opecode == 0x13) {	// SBX.
 		r1 = ip[1]; r0 = ip[3]; bit = ip[4];
-		if (bit > vm->bit[r1]) {
+		if (vm->bit[r1] != BIT_DISABLE_REG && bit > vm->bit[r1]) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
 			goto fin;
 		}
@@ -159,17 +292,17 @@ void execStepInteger(OsecpuVm *vm)
 			vm->r[r0] = vm->r[r1] |  i;
 		}
 		vm->bit[r0] = bit;
-		execStep_checkBitsRange(vm->r[r0], bit, vm);
+		vm->r[r0] = execStep_checkBitsRange(vm->r[r0], bit, vm, vm->bit[r1], 0);
 		ip += 5;
 		goto fin;
 	}
 	if (0x18 <= opecode && opecode <= 0x19) {
 		r1 = ip[1]; r2 = ip[2]; r0 = ip[3]; bit = ip[4];
-		if (bit > vm->bit[r1]) {
+		if (vm->bit[r1] != BIT_DISABLE_REG && bit > vm->bit[r1]) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
 			goto fin;
 		}
-		if (bit <= vm->r[r2] || vm->r[r2] < 0) {
+		if (vm->r[r2] < 0) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_R2);
 			goto fin;
 		}
@@ -178,13 +311,17 @@ void execStepInteger(OsecpuVm *vm)
 		else
 			vm->r[r0] = vm->r[r1] >> vm->r[r2];	// SAR
 		vm->bit[r0] = bit;
-		execStep_checkBitsRange(vm->r[r0], bit, vm);
+		vm->r[r0] = execStep_checkBitsRange(vm->r[r0], bit, vm, vm->bit[r1], 0);
 		ip += 5;
 		goto fin;
 	}
 	if (0x1a <= opecode && opecode <= 0x1b) {
 		r1 = ip[1]; r2 = ip[2]; r0 = ip[3]; bit = ip[4];
-		if (bit > vm->bit[r1] || bit > vm->bit[r2]) {
+		if (vm->bit[r1] != BIT_DISABLE_REG && bit > vm->bit[r1]) {
+			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
+			goto fin;
+		}
+		if (vm->bit[r2] != BIT_DISABLE_REG && bit > vm->bit[r2]) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
 			goto fin;
 		}
@@ -197,13 +334,17 @@ void execStepInteger(OsecpuVm *vm)
 		else
 			vm->r[r0] = vm->r[r1] % vm->r[r2];
 		vm->bit[r0] = bit;
-		execStep_checkBitsRange(vm->r[r0], bit, vm);
+		vm->r[r0] = execStep_checkBitsRange(vm->r[r0], bit, vm, vm->bit[r1], vm->bit[r2]);
 		ip += 5;
 		goto fin;
 	}
 	if (0x20 <= opecode && opecode <= 0x27) {
 		r1 = ip[1]; r2 = ip[2]; bit1 = ip[3]; r0 = ip[4]; bit0 = ip[5];
-		if (bit1 > vm->bit[r1] || bit1 > vm->bit[r2]) {
+		if (vm->bit[r1] != BIT_DISABLE_REG && bit > vm->bit[r1]) {
+			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
+			goto fin;
+		}
+		if (vm->bit[r2] != BIT_DISABLE_REG && bit > vm->bit[r2]) {
 			jitcSetRetCode(&vm->errorCode, EXEC_BAD_BITS);
 			goto fin;
 		}
@@ -230,8 +371,32 @@ void execStepInteger(OsecpuVm *vm)
 		ip += 6;
 		goto fin;
 	}
+
 fin:
-	vm->ip = ip;
+	if (vm->errorCode <= 0)
+		vm->ip = ip;
+	return;
+}
+
+void jitcStep_checkBits32(int *pRC, int bits)
+{
+	if (!(0 <= bits && bits <= 32))
+		jitcSetRetCode(pRC, JITC_BAD_BITS);
 	return;
 }
 
+void jitcStep_checkRxx(int *pRC, int rxx)
+{
+	if (!(0x00 <= rxx && rxx <= 0x3f))
+		jitcSetRetCode(pRC, JITC_BAD_RXX);
+	return;
+}
+
+void jitcStep_checkRxxNotR3F(int *pRC, int rxx)
+{
+	if (!(0x00 <= rxx && rxx <= 0x3e))
+		jitcSetRetCode(pRC, JITC_BAD_RXX);
+	return;
+}
+
+

--- a/memo.txt
+++ b/memo.txt
@@ -33,3 +33,59 @@
   data命令でも浮動小数点を使えるようになりたいからそれは後日がんばる。
   次はLMEMだなー。その次がPADD。
 
+2014.05.23金:
+  プリフィクスについて：
+    解釈できるプリフィクスは、認識した後に0クリアすること。そうしなければエラーになる。
+    2Fプリフィクスは、フラグ的な指定なので、命令ごとに意味が異なる。
+  LMEMに対する、2F-0プリフィクスについて：
+    2F-0プリフィクスがない場合：
+      (1) mem.bit < typ.bit なら、セキュリティ例外になる。
+      mem.bit: メモリのbit[]値
+      typ.bit: そのメモリの型での最大のbit値
+      reg.bit: LMEM命令内のbit値で、これは命令実行後にRxxのbit[]値になる
+    2F-0プリフィクスがある場合：
+      (1) reg.bit = min(reg.bit, mem.bit) とする。結果が何であろうとセキュリティ例外にはならない。
+      この場合、不定値をロードしてもレジスタが不定値なるだけで処理を続行できる。
+      しかしこの値を使って演算しようとすると、エラーになる。
+  SMEMに対する、2F-0プリフィクスについて：
+    2F-0プリフィクスがない場合：
+      (1) typ.bit > reg.bit なら、セキュリティ例外になる。
+      (2) typで指定されている型で表現可能な範囲にregがないのであれば、セキュリティ例外になる。
+      (3) mem.bit = typ.bit になる。
+    2F-0プリフィクスがある場合：
+      (1) typで指定されている型で表現可能な範囲にregがないのであれば、mem.bit = 0 になる。
+      (2) そうでなければ mem.bit = reg.bit になる。
+      つまり例外を起こさずに何とかする。
+      この場合、unsignedな型は指定できない。
+  SMEMに対する、2F-1プリフィクスについて：
+    2F-1プリフィクスがあると、Rxxフィールドは無視されて、メモリは無条件にbit[]値を0にされる。
+    明示的にメモリを不定値したい場合は、これが望ましい。適当なレジスタに不定値を代入して格納する方法だと
+    高速モード時に不要なSMEM命令が残ってしまうかもしれない。
+  SMEMに対する、2F-2プリフィクスについて：
+    2F-2プリフィクスがある場合：
+      (1) typ.bit > reg.bit なら、セキュリティ例外になる。
+      (2) 実際に書き込まれるのは、typ.bitでマスクされた下位の値のみ。
+      (3) mem.bit = typ.bit になる。
+  （上記のメモは、もはや古い内容。メモだから残しているだけ。）
+  data命令がpointer.cの中にあるのはうまくない！
+
+2014.05.27火:
+  レンジチェックに関する諸問題：
+  (1) 高速モードから安全モードへ切り替えることを想定すると、bit[]に「不明」を認めなければいけない。
+    しかしそうなると、レンジチェックの手順はかなり複雑になる。
+    ソースデータに「不明」がある場合、結果が出た後に結果を正規化する必要がある。
+  (2) 安全モードだけでも、C=(A+B)&3;のような計算をするときに、A+Bの結果を2ビットの精度で演算できるべきでは
+    ないか？・・・となると、A+Bの計算をするときに結果が2ビットで収まらなくても構わないということを認めなければ
+    いけない。そのために2F-0プリフィクスを付ける。
+  (3) まず論点としては、レンジチェックをやめてしまえばいいのではないかということがある。ごみデータが現れることは
+    高速モードじゃなくても十分に起こり得ることなのであって、そうなるとそれに気を使うのは面倒なだけではないか？
+    しかしとりあえず、まだあきらめずにレンジチェックをやる方向で検討する。この(3)は思考過程を記録として残すために
+    書いた。
+  (4) 2F-0プリフィクスがある場合、レンジチェックはしないで、むしろ結果がそのレンジに収まるように符号拡張をする。
+    そうしないと以後のレンジチェックに障るかもしれないので。
+  例外検出に関する諸問題：
+    例外を検出した時に、正常系だった最後の値を保持する（おかしくなった原因命令を実行する直前の状態にする）のは
+    負担が大きいので、それはやらない。これについては、将来の逆再生機能に期待するべきだ。
+  driver.cについて：
+    確かMacOS版にバグの修正があった気がするけど、まだそこまで手が回らない。落ち着いたら確認する。
+

--- a/osecpu-vm.c
+++ b/osecpu-vm.c
@@ -155,8 +155,11 @@ void jitcInitDstLogSetPhase(OsecpuJitc *jitc, int phase)
 	for (i = 0; i < JITC_DSTLOG_SIZE; i++)
 		jitc->dstLog[i] = NULL;
 	jitc->dstLogIndex = 0;
+	for (i = 0; i < PREFIX2F_SIZE; i++)
+		jitc->prefix2f[i] = 0;
 	jitc->phase = phase;
 	jitcInitInteger(jitc);
+	jitcInitOther(jitc);
 	jitcInitPointer(jitc);
 	jitcInitFloat(jitc);
 	jitcInitExtend(jitc);
@@ -184,6 +187,7 @@ int jitcStep(OsecpuJitc *jitc)
 	int retcode = -1, *pRC = &retcode, i;
 	jitc->hh4Buffer[0] = hh4ReaderGetUnsigned(&jitc->hh4r);
 	retcode = jitcStepInteger(jitc);	if (retcode >= 0) goto fin;
+	retcode = jitcStepOther(jitc);		if (retcode >= 0) goto fin;
 	retcode = jitcStepPointer(jitc);	if (retcode >= 0) goto fin;
 	retcode = jitcStepFloat(jitc);		if (retcode >= 0) goto fin;
 	retcode = jitcStepExtend(jitc);		if (retcode >= 0) goto fin;
@@ -197,10 +201,11 @@ fin:
 		goto fin1;
 	for (i = 0; i < jitc->instrLength; i++)
 		jitc->dst[i] = jitc->hh4Buffer[i];
-	jitcAfterStepInteger(jitc);
-	jitcAfterStepPointer(jitc);
-	jitcAfterStepFloat(jitc);
-	jitcAfterStepExtend(jitc);
+	retcode = jitcAfterStepInteger(jitc);	if (retcode > 0) goto fin1;
+	retcode = jitcAfterStepOther(jitc);		if (retcode > 0) goto fin1;
+	retcode = jitcAfterStepPointer(jitc);	if (retcode > 0) goto fin1;
+	retcode = jitcAfterStepFloat(jitc);		if (retcode > 0) goto fin1;
+	retcode = jitcAfterStepExtend(jitc);	if (retcode > 0) goto fin1;
 	i = jitc->dstLogIndex;
 	jitc->dstLog[i] = jitc->dst; // エラーのなかった命令は記録する.
 	jitc->dstLogIndex = (i + 1) % JITC_DSTLOG_SIZE;
@@ -236,27 +241,6 @@ fin:
 	return jitc->errorCode;
 }
 
-void jitcStep_checkBits32(int *pRC, int bits)
-{
-	if (!(0 <= bits && bits <= 32))
-		jitcSetRetCode(pRC, JITC_BAD_BITS);
-	return;
-}
-
-void jitcStep_checkRxx(int *pRC, int rxx)
-{
-	if (!(0x00 <= rxx && rxx <= 0x3f))
-		jitcSetRetCode(pRC, JITC_BAD_RXX);
-	return;
-}
-
-void jitcStep_checkRxxNotR3F(int *pRC, int rxx)
-{
-	if (!(0x00 <= rxx && rxx <= 0x3e))
-		jitcSetRetCode(pRC, JITC_BAD_RXX);
-	return;
-}
-
 // exec関係.
 
 int execStep(OsecpuVm *vm)
@@ -264,6 +248,7 @@ int execStep(OsecpuVm *vm)
 	const Int32 *ip = vm->ip;
 	vm->errorCode = 0;
 	execStepInteger(vm);	if (ip != vm->ip || vm->errorCode != 0) goto fin;
+	execStepOther(vm);		if (ip != vm->ip || vm->errorCode != 0) goto fin;
 	execStepPointer(vm);	if (ip != vm->ip || vm->errorCode != 0) goto fin;
 	execStepFloat(vm);		if (ip != vm->ip || vm->errorCode != 0) goto fin;
 	execStepExtend(vm);		if (ip != vm->ip || vm->errorCode != 0) goto fin;
@@ -280,6 +265,9 @@ fin:
 
 int execAll(OsecpuVm *vm)
 {
+	int i;
+	for (i = 0; i < PREFIX2F_SIZE; i++)
+		vm->prefix2f[i] = 0;
 	for (;;) {
 		// 理想は適当な上限を決めて、休み休みでやるべきかもしれない.
 		execStep(vm);
@@ -288,16 +276,6 @@ int execAll(OsecpuVm *vm)
 	return vm->errorCode;
 }
 
-void execStep_checkBitsRange(Int32 value, int bits, OsecpuVm *vm)
-{
-	int max, min;
-	max = 1 << (bits - 1); // 例: bits=8だとmax=128になる.
-	max--; // 例: bits=8だとmax=127になる.
-	min = - max - 1; // 例: bits=8だとmin=-128になる。
-	if (!(min <= value && value <= max))
-		jitcSetRetCode(&vm->errorCode, EXEC_BITS_RANGE_OVER);
-	return;
-}
 
 // 関連ツール関数.
 

--- a/osecpu-vm.h
+++ b/osecpu-vm.h
@@ -48,6 +48,7 @@ typedef struct _BitReader {
 } BitReader;
 
 #define JITC_DSTLOG_SIZE	16
+#define PREFIX2F_SIZE		16
 
 typedef struct _OsecpuJitc {
 	int phase, dstLogIndex;
@@ -60,6 +61,7 @@ typedef struct _OsecpuJitc {
 	int errorCode, instrLength;
 	Int32 dr[4]; // Integer
 	Int32 *ope04; // Integer
+	unsigned char prefix2f[PREFIX2F_SIZE]; // Integer
 } OsecpuJitc;
 
 typedef struct _OsecpuVm {
@@ -72,6 +74,7 @@ typedef struct _OsecpuVm {
 	const Int32 *ip, *ip1; /* instruction-pointer, program-counter */
 	const Defines *defines;
 	int errorCode;
+	unsigned char prefix2f[PREFIX2F_SIZE];
 } OsecpuVm;
 
 // osecpu-vm.c
@@ -112,10 +115,8 @@ int jitcAll(OsecpuJitc *jitc);
 #define JITC_BAD_LABEL_TYPE		14
 #define JITC_LABEL_UNDEFINED	15
 #define JITC_BAD_TYPE			16
-
-void jitcStep_checkBits32(int *pRC, int bits);
-void jitcStep_checkRxx(int *pRC, int rxx);
-void jitcStep_checkRxxNotR3F(int *pRC, int rxx);
+#define JITC_BAD_PREFIX			17
+#define JITC_UNSUPPORTED		18
 
 int execStep(OsecpuVm *r); // 検証済みのOSECPU命令を一つだけ実行する.
 int execAll(OsecpuVm *vm);
@@ -125,32 +126,62 @@ int execAll(OsecpuVm *vm);
 #define EXEC_BAD_R2				3	// SBX, SHL, SARのr2が不適切.
 #define EXEC_DIVISION_BY_ZERO	4
 #define EXEC_SRC_OVERRUN		5
+#define EXEC_TYP_MISMATCH		6
+#define EXEC_PTR_RANGE_OVER		7
+#define EXEC_BAD_ACCESS			8
+#define EXEC_API_ERROR			9
 #define EXEC_ABORT_OPECODE_M1	0xffff
 
-void execStep_checkBitsRange(Int32 value, int bits, OsecpuVm *vm);
+#define EXEC_CMA_FLAG_SEEK		1
+#define EXEC_CMA_FLAG_READ		2
+#define EXEC_CMA_FLAG_WRITE		4
+#define EXEC_CMA_FLAG_EXEC		8
+
+#define BIT_DISABLE_REG		-1
+#define BIT_DISABLE_MEM		255
+
+#define PTR_TYP_CODE			-1
+#define PTR_TYP_NATIVECODE		-2
 
 unsigned char *hh4StrToBin(unsigned char *src, unsigned char *src1, unsigned char *dst, unsigned char *dst1);
 
-// integer.c : 整数命令
+// integer.c : 整数命令.
 void jitcInitInteger(OsecpuJitc *jitc);
 int jitcStepInteger(OsecpuJitc *jitc);
-void jitcAfterStepInteger(OsecpuJitc *jitc);
+int jitcAfterStepInteger(OsecpuJitc *jitc);
 void execStepInteger(OsecpuVm *vm);
 
-// pointer.c : ポインタ命令
+int getTypBitInteger(int typ);
+void getTypInfoInteger(int typ, int *typSize0, int *typSize1, int *typSign);
+Int32 execStep_checkBitsRange(Int32 value, int bit, OsecpuVm *vm, int bit1, int bit2);
+void jitcStep_checkBits32(int *pRC, int bits);
+void jitcStep_checkRxx(int *pRC, int rxx);
+void jitcStep_checkRxxNotR3F(int *pRC, int rxx);
+
+// pointer.c : ポインタ命令.
 void jitcInitPointer(OsecpuJitc *jitc);
 int jitcStepPointer(OsecpuJitc *jitc);
-void jitcAfterStepPointer(OsecpuJitc *jitc);
+int jitcAfterStepPointer(OsecpuJitc *jitc);
 void execStepPointer(OsecpuVm *vm);
 
+void getTypSize(int typ, int *typSize0, int *typSize1, int *typSign); // これは直すべき.
+void jitcStep_checkPxx(int *pRC, int pxx);
+void execStep_checkMemAccess(OsecpuVm *vm, int p, int typ, int flag);
+
 // float.c : 浮動小数点命令
 void jitcInitFloat(OsecpuJitc *jitc);
 int jitcStepFloat(OsecpuJitc *jitc);
-void jitcAfterStepFloat(OsecpuJitc *jitc);
+int jitcAfterStepFloat(OsecpuJitc *jitc);
 void execStepFloat(OsecpuVm *vm);
 
+// other.c : 雑命令.
+void jitcInitOther(OsecpuJitc *jitc);
+int jitcStepOther(OsecpuJitc *jitc);
+int jitcAfterStepOther(OsecpuJitc *jitc);
+void execStepOther(OsecpuVm *vm);
+
 // extend.c : 拡張命令関係.
 void jitcInitExtend(OsecpuJitc *jitc);
 int jitcStepExtend(OsecpuJitc *jitc);
-void jitcAfterStepExtend(OsecpuJitc *jitc);
+int jitcAfterStepExtend(OsecpuJitc *jitc);
 void execStepExtend(OsecpuVm *vm);

--- /dev/null
+++ b/other.c
@@ -0,0 +1,87 @@
+#include "osecpu-vm.h"
+
+// その他の命令: 00, 2F, FD
+
+void jitcInitOther(OsecpuJitc *jitc)
+{
+	jitc->ope04 = NULL;
+	return;
+}
+
+int jitcStepOther(OsecpuJitc *jitc)
+{
+	Int32 *ip = jitc->hh4Buffer;
+	Int32 opecode = ip[0], imm;
+	int bit, bit0, bit1, r, r0, r1, r2, p, typ;
+	int retcode = -1, *pRC = &retcode;
+	int i, j;
+	if (opecode == 0x00) { /* NOP */
+		jitcSetHh4BufferSimple(jitc, 1);
+		goto fin;
+	}
+	if (opecode == 0x2f) {
+		jitcSetHh4BufferSimple(jitc, 2);
+		i = ip[1];
+		if (i < PREFIX2F_SIZE && jitc->prefix2f[i] == 0)
+			jitc->prefix2f[i] = 1;
+		else
+			jitcSetRetCode(pRC, JITC_BAD_PREFIX);
+		goto fin;
+	}
+	if (opecode == 0xfd) {
+		jitcSetHh4BufferSimple(jitc, 3);
+		imm = ip[1]; r = ip[2];
+ 		if (0 <= r && r <= 3)
+			jitc->dr[r] = imm;
+		goto fin;
+	}
+	goto fin1;
+fin:
+	if (retcode == -1)
+		retcode = 0;
+fin1:
+	return retcode;
+}
+
+int jitcAfterStepOther(OsecpuJitc *jitc)
+{
+	int i, retcode = 0;
+	if (jitc->hh4Buffer[0] != 0x2f) {
+		// 未解釈の2Fプリフィクスが残っていないか調査.
+		// 解釈したら0クリアするのが作法.
+		for (i = 0; i < PREFIX2F_SIZE; i++) {
+			if (jitc->prefix2f[i] != 0)
+				retcode = JITC_BAD_PREFIX;
+		}
+	}
+	return 0;
+}
+
+void execStepOther(OsecpuVm *vm)
+{
+	const Int32 *ip = vm->ip;
+	Int32 opecode = ip[0], imm;
+	int bit, bit0, bit1, r, r0, r1, r2, p, typ, typSign, typSize0, typSize1;
+	int i, mbit, tbit;
+	if (opecode == 0x00) { // NOP();
+		ip++;
+		goto fin;
+	}
+	if (opecode == 0x2f) {
+		i = ip[1];
+		vm->prefix2f[i] = 1;
+		ip += 2;
+		goto fin;
+	}
+	if (opecode == 0xfd) {
+		imm = ip[1]; r = ip[2];
+ 		if (0 <= r && r <= 3)
+			vm->dr[r] = imm;
+		goto fin;
+	}
+fin:
+	if (vm->errorCode <= 0)
+		vm->ip = ip;
+	return;
+}
+

--- a/pointer.c
+++ b/pointer.c
@@ -1,19 +1,12 @@
 #include "osecpu-vm.h"
 
-// ポインタ関連命令: 01, 03, 2E
+// ポインタ関連命令: 01, 03, 0E, 1E, 2E
 
 void jitcInitPointer(OsecpuJitc *jitc)
 {
 	return;
 }
 
-void jitcStep_checkPxx(int *pRC, int pxx)
-{
-	if (!(0x00 <= pxx && pxx <= 0x3f))
-		jitcSetRetCode(pRC, JITC_BAD_PXX);
-	return;
-}
-
 void getTypSize(int typ, int *typSize0, int *typSize1, int *typSign)
 // typSize0: 入力バイナリ内でのビット数.
 // typSize1: 出力バイナリ内でのバイト数.
@@ -39,7 +32,7 @@ int jitcStepPointer(OsecpuJitc *jitc)
 	Int32 *ip = jitc->hh4Buffer;
 	Int32 opecode = ip[0], imm;
 	int retcode = -1, *pRC = &retcode;
-	int i, j, opt, p, typ, len, typSign, typSize0, typSize1;
+	int i, j, opt, p, p0, p1, r, bit, typ, len, typSign, typSize0, typSize1;
 	if (opecode == 0x01) { /* LB(opt, uimm); */
 		jitcSetHh4BufferSimple(jitc, 3);
 		i = ip[1]; opt = ip[2];
@@ -56,7 +49,7 @@ int jitcStepPointer(OsecpuJitc *jitc)
 			jitcSetRetCode(pRC, JITC_BAD_LABEL_TYPE);
 			goto fin;
 		}
-		jitc->defines->label[i].typ = -1; // とりあえずコードラベルにする.
+		jitc->defines->label[i].typ = PTR_TYP_CODE; // とりあえずコードラベルにする.
 		jitc->defines->label[i].opt = opt;
 		jitc->defines->label[i].dst = jitc->dst;
 		goto fin;
@@ -74,11 +67,29 @@ int jitcStepPointer(OsecpuJitc *jitc)
 			jitcSetRetCode(pRC, JITC_LABEL_UNDEFINED);
 		if (p != 0x3f && jitc->defines->label[i].opt == 0)
 			jitcSetRetCode(pRC, JITC_BAD_LABEL_TYPE);
-		if (p == 0x3f && jitc->defines->label[i].typ != -1)
+		if (p == 0x3f && jitc->defines->label[i].typ != PTR_TYP_CODE)
 			jitcSetRetCode(pRC, JITC_BAD_LABEL_TYPE); // P3Fにデータラベルを代入できない.
 		goto fin;
 	}
-	if (opecode == 0x2e) { // data
+	if (opecode == 0x0e) {	// PADD(r, bit, p1, typ, p0);
+		jitcSetHh4BufferSimple(jitc, 6);
+		r = ip[1]; bit = ip[2]; p1 = ip[3]; typ = ip[4]; p0 = ip[5];
+		jitcStep_checkPxx(pRC, p0);
+		jitcStep_checkPxx(pRC, p1);
+		jitcStep_checkRxx(pRC, r);
+		jitcStep_checkBits32(pRC, bit);
+		goto fin;
+	}
+	if (opecode == 0x1e) {	// PCP(p1, p0);
+		jitcSetHh4BufferSimple(jitc, 3);
+		p1 = ip[1]; p0 = ip[2];
+		jitcStep_checkPxx(pRC, p0);
+		jitcStep_checkPxx(pRC, p1);
+		if (p1 == 0x3f)
+			jitcSetRetCode(pRC, JITC_BAD_PXX);
+		goto fin;
+	}
+	if (opecode == 0x2e) { // data...これはother.cへ移動させるべき
 		BitReader br;
 		typ = hh4ReaderGetUnsigned(&jitc->hh4r);
 		len = hh4ReaderGetUnsigned(&jitc->hh4r);
@@ -88,7 +99,7 @@ int jitcStepPointer(OsecpuJitc *jitc)
 			goto fin;
 		}
 		jitc->instrLength = 0; // 自前で処理するので、この値は0にする.
-		if (jitc->dst + 3 + (typSize1 * len + 3) / 4 > jitc->dst1) {
+		if (jitc->dst + 3 + (typSize1 * len + 3) / 4 + (len + 3) / 4 > jitc->dst1) {
 			jitcSetRetCode(pRC, JITC_DST_OVERRUN);
 			goto fin;
 		}
@@ -132,12 +143,14 @@ int jitcStepPointer(OsecpuJitc *jitc)
 			}
 			jitc->dst += (typSize1 * len + 3) / 4;
 			unsigned char *puc = (unsigned char *) jitc->dst;
+			int tbit = getTypBitInteger(typ);
 			for (i = 0; i < len; i++)
-				puc[i] = 0xff; // bits=255.
+				puc[i] = tbit;
 			jitc->dst += (len + 3) / 4;
 		}
 		for (j = 0; j < JITC_DSTLOG_SIZE; j++) {
-			Int32 *dstLog = jitc->dstLog[jitc->dstLogIndex + JITC_DSTLOG_SIZE - 1 - j];
+			Int32 *dstLog = jitc->dstLog[(jitc->dstLogIndex + JITC_DSTLOG_SIZE - 1 - j) % JITC_DSTLOG_SIZE];
+				// 1つ前、2つ前、3つ前...の命令をチェックしている.
 			if (dstLog == NULL) break;
 			if (dstLog[0] != 0x01) break;
 			i = dstLog[1];
@@ -155,16 +168,16 @@ fin1:
 	return retcode;
 }
 
-void jitcAfterStepPointer(OsecpuJitc *jitc)
+int jitcAfterStepPointer(OsecpuJitc *jitc)
 {
-	return;
+	return 0;
 }
 
 void execStepPointer(OsecpuVm *vm)
 {
 	const Int32 *ip = vm->ip;
 	Int32 opecode = ip[0];
-	int i, p, typ, len, typSign, typSize0, typSize1;
+	int i, p, r, p0, p1, bit, typ, len, typSign, typSize0, typSize1;
 	if (opecode == 0x01) { /* LB(opt, uimm); */
 		ip += 3;
 		goto fin;
@@ -175,17 +188,21 @@ void execStepPointer(OsecpuVm *vm)
 			ip = (const Int32 *) vm->defines->label[i].dst;
 		else {
 			typ = vm->defines->label[i].typ;
-			vm->p[p].p = (unsigned char *) vm->defines->label[i].dst;
 			vm->p[p].typ = typ;
-			vm->p[p].p0 = vm->p[p].p;
 			if (typ >= 2) {
+				vm->p[p].p = (unsigned char *) (vm->defines->label[i].dst + 3);
+				vm->p[p].p0 = vm->p[p].p;
 				len = vm->defines->label[i].dst[2]; // 2e(data)のlenフィールド値.
-				getTypSize(typ, NULL, &typSize1, NULL);
+				getTypSize(typ, &typSize0, &typSize1, &typSign);
 				vm->p[p].p1 = vm->p[p].p + typSize1 * len;
 				vm->p[p].bit = vm->p[p].p + ((typSize1 * len + 3) / 4) * 4;
+				vm->p[p].flags = 6; // over-seek:ok, read:ok, write:ok
 			}
-			if (typ == -1) {	// コードラベル.
+			if (typ == PTR_TYP_CODE) {	// コードラベル.
+				vm->p[p].p = (unsigned char *) vm->defines->label[i].dst;
+				vm->p[p].p0 = vm->p[p].p;
 				vm->p[p].p1 = vm->p[p].p + 1;
+				vm->p[p].flags = 0; // over-seek:ok, read:err, write:err
 			}
 			if (typ == 1) {		// VPtr.
 			}
@@ -193,6 +210,40 @@ void execStepPointer(OsecpuVm *vm)
 		}
 		goto fin;
 	}
+	if (opecode == 0x0e) {	// PADD(r, bit, p1, typ, p0);
+		r = ip[1]; bit = ip[2]; p1 = ip[3]; typ = ip[4]; p0 = ip[5];
+		getTypSize(typ, &typSize0, &typSize1, &typSign);
+		i = execStep_checkBitsRange(vm->r[r], bit, vm, 0, 0);
+		vm->p[p0] = vm->p[p1];
+		vm->p[p0].p += i * typSize1;
+		vm->p[p0].bit += i;
+		execStep_checkMemAccess(vm, p0, typ, EXEC_CMA_FLAG_SEEK);
+		ip += 6;
+	}
+	if (opecode == 0x1e) {	// PCP(p1, p0);
+		p1 = ip[1]; p0 = ip[2];
+		if (p0 == 0x3f) {
+			if (vm->p[p1].typ == PTR_TYP_CODE) {	// code
+				execStep_checkMemAccess(vm, p1, PTR_TYP_CODE, EXEC_CMA_FLAG_EXEC); // 主にliveSignのチェック.
+				if (vm->errorCode != 0) goto fin;
+				ip = (const Int32 *) vm->p[p1].p;
+			}
+			if (vm->p[p1].typ == PTR_TYP_NATIVECODE) {	// native-code (API)
+				const Int32 *(*func)(OsecpuVm *);
+				const Int32 *nextIp;
+				func = (void *) vm->p[p1].p;
+				nextIp = (*func)(vm);
+				if (nextIp != NULL)
+					ip = nextIp;
+				else
+					jitcSetRetCode(&vm->errorCode, EXEC_API_ERROR);
+			}
+		} else {
+			vm->p[p0] = vm->p[p1];
+			ip += 3;
+		}
+		goto fin;
+	}
 	if (opecode == 0x2e) {	// data
 		typ = ip[1]; len = ip[2];
 		getTypSize(typ, &typSize0, &typSize1, &typSign);
@@ -204,3 +255,31 @@ fin:
 	return;
 }
 
+void jitcStep_checkPxx(int *pRC, int pxx)
+{
+	if (!(0x00 <= pxx && pxx <= 0x3f))
+		jitcSetRetCode(pRC, JITC_BAD_PXX);
+	return;
+}
+
+void execStep_checkMemAccess(OsecpuVm *vm, int p, int typ, int flag)
+{
+	if (vm->p[p].typ != typ)
+		jitcSetRetCode(&vm->errorCode, EXEC_TYP_MISMATCH);
+	if (vm->p[p].p < vm->p[p].p0 || vm->p[p].p1 <= vm->p[p].p) {
+		if (flag != EXEC_CMA_FLAG_SEEK)
+			jitcSetRetCode(&vm->errorCode, EXEC_PTR_RANGE_OVER);
+		else {
+			if ((vm->p[p].flags & 1) != 0)
+				jitcSetRetCode(&vm->errorCode, EXEC_PTR_RANGE_OVER); // over-seek検出.
+		}
+	}
+	if (flag == EXEC_CMA_FLAG_READ  && (vm->p[p].flags & EXEC_CMA_FLAG_READ)  == 0)
+		jitcSetRetCode(&vm->errorCode, EXEC_BAD_ACCESS);
+	if (flag == EXEC_CMA_FLAG_WRITE && (vm->p[p].flags & EXEC_CMA_FLAG_WRITE) == 0)
+		jitcSetRetCode(&vm->errorCode, EXEC_BAD_ACCESS);
+
+	// ToDo: liveSignに対応する.
+	return;
+}
+

--- a/test.c
+++ b/test.c
@@ -1,5 +1,7 @@
 #include "osecpu-vm.h"
 
+void apiInit(OsecpuVm *vm);
+
 #define BUFFER_SIZE		256
 
 int main(int argc, const char **argv)
@@ -60,8 +62,15 @@ int main(int argc, const char **argv)
 		"1 2 1"							// LB1(2);
 		"ae 2 84 01 23 45 67"			// data(UINT8, 4, 0x01, 0x23, 0x45, 0x67);
 		"3 2 1"							// PLIMM(P01, 2);
-		"2 1 3 a0"						// LIMM32(R03, 1);
+		"2 84 3 a0"						// LIMM32(R03, 4);
+		"2 2 bf a0"						// LIMM32(R3F, 2);
+		"8e bf a0 1 2 1"				// PADD32(P01, UINT8, P01, R3F);
+		"88 1 2 0 3 a0"					// LMEM32(P01, UINT8, 0, R03);
 #endif
+		"2 84 b0 a0"					// LIMM32(R30, 4);
+		"3 3 b0"						// PLIMM(P30, 3);
+		"9e a8 bf"						// PCP(P3F, P28);
+		"1 3 1"							// LB1(3);
 
 		, NULL, hh4src, &hh4src[BUFFER_SIZE]
 	);
@@ -84,6 +93,7 @@ int main(int argc, const char **argv)
 	vm.ip1 = jitc.dst;
 	// この時点で、i32buf[]は破棄しても良い.
 
+	apiInit(&vm);
 	// execAll()を使って、j32buf[]内の中間コードを実行する.
 	printf("execAll()=%d\n", execAll(&vm)); // 65535なら成功(EXEC_ABORT_OPECODE_M1).
 	printf("R00=%d\n", vm.r[0x00]);