Commit: 148 - kmbasic (svn)

BASIC compiler/interpreter for PIC32MX/MZ-80K (suspended)

Commit MetaInfo

• Revision: 148 (tree)
• Time: 2016-08-05 03:35:13
• Author: kmorimatsu

Log Message

MachiKania type Z ver 1.00

Change Summary

• added: mips/tags/zoea1.00/editor.c
• added: mips/tags/zoea1.00/main.h
• added: mips/tags/zoea1.00/editor.h
• added: mips/tags/zoea1.00/debug.c
• added: mips/tags/zoea1.00/library.c
• added: mips/tags/zoea1.00/music.c
• added: mips/tags/zoea1.00/help.txt
• added: mips/tags/zoea1.00/run.c
• added: mips/tags/zoea1.00/compiler.c
• added: mips/tags/zoea1.00/file.c
• added: mips/tags/zoea1.00/compiler.h
• added: mips/tags/zoea1.00/function.c
• added: mips/tags/zoea1.00/string.c
• added: mips/tags/zoea1.00/statement.c
• added: mips/tags/zoea1.00/linker.c
• added: mips/tags/zoea1.00/float.c
• added: mips/tags/zoea1.00/videoout.h
• added: mips/tags/zoea1.00/error.c
• added: mips/tags/zoea1.00/globalvars.c
• added: mips/tags/zoea1.00/value.c
• added: mips/tags/zoea1.00/exception.c
• added: mips/tags/zoea1.00/debug.h
• added: mips/tags/zoea1.00/App_32MX170F256B.ld
• added: mips/tags/zoea1.00/main.c
• added: mips/tags/zoea1.00/api.h
• added: mips/tags/zoea1.00/basic.mcp
• added: mips/tags/zoea1.00/operator.c
• added: mips/tags/zoea1.00/memory.c
• added: mips/tags/zoea1.00/keyinput.c
• added: mips/tags/zoea1.00/ps2keyboard.h
• added: mips/tags/zoea1.00/MACHIKAN.INI
• added: mips/tags/zoea1.00/keyinput.h
• added: mips/tags/zoea1.00/SDFSIO.h
• added: mips/tags/zoea1.00

Incremental Difference

--- mips/tags/zoea1.00/editor.c	(nonexistent)
+++ mips/tags/zoea1.00/editor.c	(revision 148)
@@ -0,0 +1,1861 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "editor.h"
+#include "keyinput.h"
+#include "compiler.h"
+#include "main.h"
+
+struct _TBUF{
+//リンク付きのテキストバッファ
+	struct _TBUF *prev;//前方へのリンク。NULLの場合先頭または空き
+	struct _TBUF *next;//後方へのリンク。NULLの場合最後
+	unsigned short n;//現在の使用バイト数
+	unsigned char Buf[TBUFSIZE];//バッファ
+} ;
+typedef struct _TBUF _tbuf;
+
+//_tbuf TextBuffer[TBUFMAXLINE]; //テキストバッファ
+_tbuf *TextBuffer; //実体は配列RAM[]の中に確保する
+
+_tbuf *TBufstart; //テキストバッファの先頭位置
+_tbuf *cursorbp; //現在のカーソル位置のテキストバッファ
+unsigned short cursorix; //現在のカーソル位置のテキストバッファ先頭からの位置
+_tbuf *disptopbp; //現在表示中画面左上のテキストバッファ
+unsigned short disptopix; //現在表示中画面左上のテキストバッファ先頭からの位置
+int num; //現在バッファ内に格納されている文字数
+int cx,cy; //カーソル座標
+int cx2; //上下移動時の仮カーソルX座標
+_tbuf *cursorbp1; //範囲選択時のカーソルスタート位置のテキストバッファ、範囲選択モードでない場合NULL
+unsigned short cursorix1; //範囲選択時のカーソルスタート位置のテキストバッファ先頭からの位置
+int cx1,cy1; //範囲選択時のカーソルスタート座標
+
+// カーソル関連位置の一時避難用
+_tbuf *cursorbp_t;
+unsigned short cursorix_t;
+_tbuf *disptopbp_t;
+unsigned short disptopix_t;
+int cx_t,cy_t;
+
+//unsigned char clipboard[EDITWIDTHX*EDITWIDTHY]; //クリップボード、最大サイズは編集画面領域と同じ
+unsigned char *clipboard; //実体は配列RAM[]の中に確保する
+
+int clipsize; //現在クリップボードに格納されている文字数
+int edited; //保存後に変更されたかを表すフラグ
+
+//unsigned char filebuf[FILEBUFSIZE]; //ファイルアクセス用バッファ
+unsigned char *filebuf; //実体は配列RAM[]の中に確保する
+
+unsigned char currentfile[13],tempfile[13]; //編集中のファイル名、一時ファイル名
+
+//unsigned char filenames[MAXFILENUM][13]; //ロード時のファイル名一覧バッファ
+unsigned char (*filenames)[13]; //実体は配列RAM[]の中に確保する
+
+const unsigned char Message1[]="Hit Any Key\n";
+const unsigned char Message2[]="File System Error\n";
+const unsigned char Message3[]="Retry:[Enter] / Quit:[ESC]\n";
+void wait60thsec(unsigned short n){
+	// 60分のn秒ウェイト（ビデオ画面の最下行信号出力終了まで待つ）
+	n+=drawcount;
+	while(drawcount!=n) asm(WAIT);
+}
+
+unsigned int bpixtopos(_tbuf *bp,unsigned int ix){
+// テキストバッファ上の位置からテキスト全体の先頭から何文字目かを返す
+// bp:テキストバッファポインタ
+// ix:bp->Bufの先頭からの文字数
+	unsigned int pos;
+	_tbuf *sbp;
+	pos=0;
+	sbp=TBufstart;
+	while(sbp!=bp){
+		pos+=sbp->n;
+		sbp=sbp->next;
+		if(sbp==NULL) return 0; //エラー
+	}
+	return pos+ix;
+}
+_tbuf * postobpix(int pos,unsigned short *pix){
+// テキスト全体の先頭からpos文字目のテキストバッファ上の位置を返す
+// 戻り値　テキストバッファポインタ
+// *pix（戻り値）：戻り値テキストバッファの先頭からの位置（ポインタ渡し）
+	_tbuf *bp;
+	bp=TBufstart;
+	while(pos >= bp->n){
+		if(bp->next==NULL) break; //全体最後尾の場合
+		pos-=bp->n;
+		bp=bp->next;
+	}
+	if(pos > bp->n){
+		// オーバーランエラーの場合先頭を返す
+		*pix=0;
+		return TBufstart;
+	}
+	*pix=pos;
+	return bp;
+}
+_tbuf * linetobpix(int line,unsigned short *pix){
+// テキスト全体の先頭からline行目のテキストバッファ上の位置を返す
+// 戻り値　テキストバッファポインタ
+// *pix（戻り値）：戻り値テキストバッファの先頭からの位置（ポインタ渡し）
+	_tbuf *bp,*bp2;
+	int ix,ix2;
+	bp=TBufstart;
+	bp2=TBufstart;
+	ix=0;
+	ix2=0;
+	while(line>1){
+		while(1){
+			if(ix>=bp->n){
+				if(bp->next==NULL) break;
+				bp=bp->next;
+				ix=0;
+				continue;
+			}
+			if(bp->Buf[ix++] == '\n'){
+				bp2=bp;
+				ix2=ix;
+				break;
+			}
+		}
+		line--;
+	}
+	*pix=ix2;
+	return bp2;
+}
+
+_tbuf * newTBuf(_tbuf *prev){
+// 新しいテキストバッファ1行を生成
+// prev:挿入先の行（prevの後ろに追加）
+// 戻り値　生成したバッファへのポインタ、生成できない場合NULL
+	_tbuf *bp,*next;
+
+	//バッファの先頭から空きをサーチ
+	bp=TextBuffer;
+	while(1){
+		if(bp->prev==NULL && bp!=TBufstart) break;
+		bp++;
+		if(bp>=TextBuffer+TBUFMAXLINE) return NULL;//最後まで空きなし
+	}
+	next=prev->next;
+	//行挿入
+	bp->prev=prev;
+	bp->next=next;
+	prev->next=bp;
+	if(next!=NULL) next->prev=bp;
+	bp->n=0;
+	return bp;
+}
+
+_tbuf * deleteTBuf(_tbuf *bp){
+// テキストバッファの削除
+// bp:削除する行のポインタ
+// 戻り値　削除前の次のバッファへのポインタ、ない場合NULL
+	unsigned short a,b;
+	_tbuf *prev,*next;
+	prev=bp->prev;
+	next=bp->next;
+	if(prev==NULL){
+		//先頭行の場合
+		if(next==NULL) return next; //最後の1行の場合は削除しない
+		TBufstart=next; //次の行を先頭行設定
+	}
+	else prev->next=next; //前を次にリンク（最終行ならNULLがコピーされる）
+	if(next!=NULL) next->prev=prev; //次があれば次を前にリンク
+	bp->prev=NULL; //空きフラグ設定
+	return next;
+}
+
+int insertchar(_tbuf *bp,unsigned int ix,unsigned char c){
+//テキストバッファbpの先頭からixバイトの位置にcを挿入
+//戻り値　成功：0、不正または容量オーバー：-1、空きがあるはずなのに失敗：1
+	unsigned char *p;
+
+	if(ix > bp->n) return -1; //不正指定
+	if(num >= TBUFMAXSIZE) return -1; //バッファ容量オーバー
+	if(bp->n < TBUFSIZE){
+		//ライン内だけで1バイト挿入可能//
+		for(p=bp->Buf + bp->n ; p > bp->Buf+ix ; p--) *p=*(p-1);
+		*p=c;
+		bp->n++;
+		num++; //バッファ使用量
+//		if(bp->n >= TBUFSIZE && bp->next==NULL) newTBuf(bp); //バッファがいっぱいになったら新たにバッファ生成
+		return 0;
+	}
+	//ラインがあふれる場合
+	if(bp->next==NULL || bp->next->n >=TBUFSIZE){
+		// 最終行または次のラインバッファがいっぱいだったら一行挿入
+		if(newTBuf(bp)==NULL){
+			// ラインバッファ挿入不可
+			return 1;
+		}
+	}
+	if(ix==TBUFSIZE){
+		insertchar(bp->next,0,c);
+		return 0;
+	}
+	p=bp->Buf + TBUFSIZE-1;
+	insertchar(bp->next,0,*p); //次の行の先頭に1文字挿入（必ず空きあり）
+	for( ; p > bp->Buf+ix ; p--) *p=*(p-1);
+	*p=c;
+	return 0;
+}
+
+int overwritechar(_tbuf *bp,unsigned int ix,unsigned char c){
+//テキストバッファbpの先頭からixバイトの位置をcで上書き
+//戻り値　成功：0、不正または容量オーバー：-1、空きがあるはずなのに失敗：1
+
+	//現在のバッファ位置の文字が終端または改行の場合、挿入モード
+	if(ix > bp->n) return -1; //不正指定
+	while(ix >= bp->n){
+		if(bp->next==NULL){
+			//テキスト全体最後尾の場合は挿入
+			return insertchar(bp,ix,c);
+		}
+		bp=bp->next;
+		ix=0;
+	}
+	if(bp->Buf[ix]=='\n') return insertchar(bp,ix,c);
+	else bp->Buf[ix]=c;
+	return 0;
+}
+
+void deletechar(_tbuf *bp,unsigned int ix){
+//テキストバッファbpの先頭からkバイトの位置の1バイト削除
+	unsigned char *p;
+
+	if(ix > bp->n) return; //不正指定
+	if(ix !=bp->n){
+		//バッファの最後の文字より後ろでない場合
+		for(p=bp->Buf+ix ; p< bp->Buf + bp->n-1 ; p++) *p=*(p+1);
+		bp->n--;
+		num--; //バッファ使用量
+		return;
+	}
+	//行バッファの現在の最後の場合（削除する文字がない場合）
+	if(bp->next==NULL) return; //全体の最後の場合、何もしない
+	deletechar(bp->next,0); //次の行の先頭文字を削除
+}
+int gabagecollect1(void){
+//断片化されたテキストバッファの隙間を埋めるガベージコレクション
+//カーソルの前と後ろそれぞれ探索して最初の1バイト分のみ実施
+//戻り値 1バイトでも移動した場合：1、なかった場合：0
+
+	_tbuf *bp;
+	int f=0;
+	unsigned char *p,*p2;
+
+	//カーソルがバッファの先頭にある場合、前のバッファの最後尾に変更
+	//（ただし前に空きがない場合と先頭バッファの場合を除く）
+	while(cursorix==0 && cursorbp->prev!=NULL && cursorbp->prev->n <TBUFSIZE){
+		cursorbp=cursorbp->prev;
+		cursorix=cursorbp->n;
+	}
+	//画面左上位置がバッファの先頭にある場合、前のバッファの最後尾に変更
+	//（ただし先頭バッファの場合を除く）
+	while(disptopix==0 && disptopbp->prev!=NULL){
+		disptopbp=disptopbp->prev;
+		disptopix=disptopbp->n;
+	}
+	//カーソルのあるバッファ以外の空バッファを全て削除
+	bp=TBufstart;
+	while(bp!=NULL){
+		if(bp->n == 0 && bp!=cursorbp) bp=deleteTBuf(bp); //空きバッファ削除
+		else bp=bp->next;
+	}
+
+	//カーソル位置より前の埋まっていないバッファを先頭からサーチ
+	bp=TBufstart;
+	while(bp->n >= TBUFSIZE){
+		if(bp==cursorbp) break;
+		bp=bp->next;
+	}
+	if(bp!=cursorbp){
+		//最初に見つけた空き場所に次のバッファから1バイト移動
+		bp->Buf[bp->n++] = bp->next->Buf[0];
+		bp=bp->next;
+		p=bp->Buf;
+		p2=p+bp->n-1;
+		for( ; p<p2 ; p++) *p=*(p+1);
+		bp->n--;
+		f=1;
+		if(bp == disptopbp) disptopix--;
+		if(bp == cursorbp) cursorix--;
+//		else if(bp->n == 0) deleteTBuf(bp);
+	}
+	if(cursorbp->next ==NULL) return f; //カーソル位置が最終バッファなら終了
+	//カーソル位置の次のバッファから埋まっていないバッファをサーチ
+	bp=cursorbp;
+	do{
+		bp=bp->next;
+		if(bp->next ==NULL) return f; //最終バッファに到達なら終了
+	} while(bp->n >=TBUFSIZE);
+
+	//最初に見つけた空き場所に次のバッファから1バイト移動
+	bp->Buf[bp->n++] = bp->next->Buf[0];
+	bp=bp->next;
+	p=bp->Buf;
+	p2=p+bp->n-1;
+	for( ; p<p2 ; p++) *p=*(p+1);
+	bp->n--;
+	f=1;
+	if(bp->n == 0) deleteTBuf(bp);
+	return f;
+}
+void gabagecollect2(void){
+// 変化がなくなるまで1バイト分のガベージコレクションを呼び出し
+	while(gabagecollect1()) ;
+}
+void inittextbuf(void){
+// テキストバッファの初期化
+	_tbuf *bp;
+	for(bp=TextBuffer;bp<TextBuffer+TBUFMAXLINE;bp++) bp->prev=NULL; //未使用バッファ化
+	TBufstart=TextBuffer; //リンクの先頭設定
+	TBufstart->next=NULL;
+	TBufstart->n=0;
+	num=0; //バッファ使用量
+	edited=0; //編集済みフラグクリア
+}
+void redraw(){
+//画面の再描画
+	unsigned char *vp;
+	_tbuf *bp,*bp1,*bp2;
+	int ix,ix1,ix2;
+	int x,y;
+	unsigned char ch,cl;
+
+	vp=TVRAM;
+	bp=disptopbp;
+	ix=disptopix;
+	cl=COLOR_NORMALTEXT;
+	if(cursorbp1==NULL){
+		//範囲選択モードでない場合
+		bp1=NULL;
+		bp2=NULL;
+	}
+	else{
+		//範囲選択モードの場合、開始位置と終了の前後判断して
+		//bp1,ix1を開始位置、bp2,ix2を終了位置に設定
+		if(cy<cy1 || (cy==cy1 && cx<cx1)){
+			bp1=cursorbp;
+			ix1=cursorix;
+			bp2=cursorbp1;
+			ix2=cursorix1;
+		}
+		else{
+			bp1=cursorbp1;
+			ix1=cursorix1;
+			bp2=cursorbp;
+			ix2=cursorix;
+		}
+	}
+	for(y=0;y<EDITWIDTHY;y++){
+		if(bp==NULL) break;
+		for(x=0;x<EDITWIDTHX;x++){
+			//文字がある位置までサーチ
+			while(ix>=bp->n){
+				if(bp==bp1 && ix==ix1) cl=COLOR_AREASELECTTEXT;
+				if(bp==bp2 && ix==ix2) cl=COLOR_NORMALTEXT;
+				bp=bp->next;
+				ix=0;
+				if(bp==NULL) break;
+			}
+			if(bp==NULL) break; //バッファ最終
+			if(bp==bp1 && ix==ix1) cl=COLOR_AREASELECTTEXT;
+			if(bp==bp2 && ix==ix2) cl=COLOR_NORMALTEXT;
+			ch=bp->Buf[ix++];
+			if(ch=='\n') break;
+			*(vp+ATTROFFSET)=cl;
+			*vp++=ch;
+		}
+		//改行およびバッファ最終以降の右側表示消去
+		for(;x<EDITWIDTHX;x++){
+			*(vp+ATTROFFSET)=0;
+			*vp++=0;
+		}
+	}
+	//バッファ最終以降の下側表示消去
+	for(;y<EDITWIDTHY;y++){
+		for(x=0;x<EDITWIDTHX;x++){
+			*(vp+ATTROFFSET)=0;
+			*vp++=0;
+		}
+	}
+}
+
+void cursor_left(void){
+//カーソルを1つ前に移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cy 画面上のカーソル位置
+//cx2 cxと同じ
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int i;
+	int x;
+
+	//バッファ上のカーソル位置を1つ前に移動
+	if(cursorix!=0) cursorix--;
+	else while(1) {
+		//1つ前のバッファの最後尾に移動、ただし空バッファは飛ばす
+		if(cursorbp->prev==NULL) return; //テキスト全体先頭なので移動しない
+		cursorbp=cursorbp->prev;
+		if(cursorbp->n >0){
+			cursorix=cursorbp->n-1;//バッファ最後尾
+			break;
+		}
+	}
+
+	//カーソルおよび画面左上位置の更新
+	if(cx>0){
+		//左端でなければカーソルを単純に1つ左に移動して終了
+		cx--;
+		cx2=cx;
+		return;
+	}
+	if(cy>0){
+		//左端だが上端ではない場合
+		if(cursorbp->Buf[cursorix]!='\n'){
+			// 移動先が改行コードでない場合、カーソルは1つ上の行の右端に移動
+			cx=EDITWIDTHX-1;
+			cx2=cx;
+			cy--;
+			return;
+		}
+		//画面左上位置から最後尾のX座標をサーチ
+		bp=disptopbp;
+		ix=disptopix;
+		x=0;
+		while(ix!=cursorix || bp!=cursorbp){
+			if(bp->n==0){
+				//空バッファの場合次へ
+				bp=bp->next;
+				ix=0;
+				continue;
+			}
+			if(bp->Buf[ix++]=='\n' || x>=EDITWIDTHX-1) x=0;
+			else x++;
+			if(ix >= bp->n){
+				bp=bp->next;
+				ix=0;
+			}
+		}
+		cx=x;
+		cx2=cx;
+		cy--;
+		return;
+	}
+
+	//左端かつ上端の場合
+	if(cursorbp->Buf[cursorix]!='\n'){
+		// 移動先が改行コードでない場合、カーソルは右端に移動
+		// 画面左上位置は画面横幅分前に移動
+		cx=EDITWIDTHX-1;
+		cx2=cx;
+	}
+	else{
+		//移動先が改行コードの場合
+		//行頭（改行の次の文字またはバッファ先頭）と現在位置の文字数差を
+		//画面横幅で割った余りがカーソルX座標
+		bp=cursorbp;
+		ix=cursorix;
+		i=0;
+		while(1){
+			if(ix==0){
+				if(bp->prev==NULL) break;
+				bp=bp->prev;
+				ix=bp->n;
+				continue;
+			}
+			ix--;
+			if(bp->Buf[ix]=='\n') break;
+			i++;
+		}
+		cx=i % EDITWIDTHX;
+		cx2=cx;
+	}
+	//画面左上位置は現在位置からX座標分引いたところ
+	bp=cursorbp;
+	ix=cursorix;
+	x=cx;
+	while(x>0){
+		if(ix==0){
+			bp=bp->prev;
+			ix=bp->n;
+			continue;
+		}
+		ix--;
+		x--;
+	}
+	disptopbp=bp;
+	disptopix=ix;
+}
+void cursor_right(void){
+//カーソルを1つ後ろに移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cy 画面上のカーソル位置
+//cx2 cxと同じ
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int i;
+	int x;
+	unsigned char c;
+
+	if(cursorix >= cursorbp->n){
+		//バッファ最後尾の場合、次の先頭に移動
+		bp=cursorbp;
+		while(1) {
+			//空バッファは飛ばす
+			if(bp->next==NULL) return; //テキスト全体最後尾なので移動しない
+			bp=bp->next;
+			if(bp->n >0) break;
+		}
+		cursorbp=bp;
+		cursorix=0;//バッファ先頭
+	}
+	c=cursorbp->Buf[cursorix++]; //バッファ上のカーソル位置のコードを読んで1つ後ろに移動
+	if(c!='\n' && cx<EDITWIDTHX-1){
+		//カーソル位置が改行でも右端でもない場合単純に1つ右に移動して終了
+		cx++;
+		cx2=cx;
+		return;
+	}
+	cx=0; //カーソルを右端に移動
+	cx2=cx;
+	if(cy<EDITWIDTHY-1){
+		//下端でなければカーソルを次行に移動して終了
+		cy++;
+		return;
+	}
+	//下端の場合
+	//画面左上位置を更新
+	//改行コードまたは画面横幅超えるまでサーチ
+	bp=disptopbp;
+	ix=disptopix;
+	x=0;
+	while(x<EDITWIDTHX){
+		if(ix >= bp->n){
+			bp=bp->next;
+			ix=0;
+			continue;
+		}
+		if(bp->Buf[ix++]=='\n') break;
+		x++;
+	}
+	disptopbp=bp;
+	disptopix=ix;
+}
+void cursor_up(void){
+//カーソルを1つ上に移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cy 画面上のカーソル位置
+//cx2 移動前のcxと同じ
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int i;
+	int x;
+	unsigned char c;
+
+	//画面幅分前に戻ったところがバッファ上カーソルの移動先
+	//途中で改行コードがあれば別の手段で検索
+	bp=cursorbp;
+	ix=cursorix;
+	i=cx2-cx;
+	while(i<EDITWIDTHX){
+		if(ix==0){
+			if(bp->prev==NULL) return; //バッファ先頭までサーチしたら移動なし
+			bp=bp->prev;
+			ix=bp->n;
+			continue;
+		}
+		ix--;
+		if(bp->Buf[ix]=='\n') break;
+		i++;
+	}
+	cursorbp=bp;
+	cursorix=ix;
+	//画面幅の間に改行コードがなかった場合
+	if(i==EDITWIDTHX){
+		cx=cx2;
+		//画面上端でなければカーソルを1つ上に移動して終了
+		if(cy>0){
+			cy--;
+			return;
+		}
+		//画面上端の場合、カーソル位置からX座標分戻ったところが画面左上位置
+		x=cx;
+		while(x>0){
+			if(ix==0){
+				bp=bp->prev;
+				ix=bp->n;
+				continue;
+			}
+			ix--;
+			x--;
+		}
+		disptopbp=bp;
+		disptopix=ix;
+		return;
+	}
+	//改行が見つかった場合
+	//行頭（改行の次の文字またはバッファ先頭）と現在位置の文字数差を
+	//画面横幅で割った余りを求める
+	i=0;
+	while(1){
+		if(ix==0){
+			if(bp->prev==NULL) break;
+			bp=bp->prev;
+			ix=bp->n;
+			continue;
+		}
+		ix--;
+		if(bp->Buf[ix]=='\n') break;
+		i++;
+	}
+	x=i % EDITWIDTHX; //改行ブロックの最終行の右端
+	bp=cursorbp;
+	ix=cursorix;
+	//バッファ上のカーソル位置は改行ブロックの最終行右端からカーソルX座標分戻る
+	//最終行右端のほうが小さい場合、その場所をバッファ上のカーソル位置とする
+	while(x>cx2){
+		if(ix==0){
+			bp=bp->prev;
+			ix=bp->n;
+			continue;
+		}
+		ix--;
+		x--;
+	}
+	cursorbp=bp;
+	cursorix=ix;
+	cx=x; //cx2または改行ブロック最終行右端
+	if(cy>0){
+		//画面上端でなければカーソルを1つ上に移動して終了
+		cy--;
+		return;
+	}
+	//画面上端の場合
+	//画面左上位置は現在位置からX座標分引いたところ
+	while(x>0){
+		if(ix==0){
+			bp=bp->prev;
+			ix=bp->n;
+			continue;
+		}
+		ix--;
+		x--;
+	}
+	disptopbp=bp;
+	disptopix=ix;
+}
+void cursor_down(void){
+//カーソルを1つ下に移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cy 画面上のカーソル位置
+//cx2 移動前のcxと同じ
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int x;
+	unsigned char c;
+
+	//次行の先頭サーチ
+	//カーソル位置から画面右端までの間に改行コードがあれば次の文字が先頭
+	bp=cursorbp;
+	ix=cursorix;
+	x=cx;
+	while(x<EDITWIDTHX){
+		if(ix>=bp->n){
+			if(bp->next==NULL) return; //バッファ最後までサーチしたら移動なし
+			bp=bp->next;
+			ix=0;
+			continue;
+		}
+		c=bp->Buf[ix];
+		ix++;
+		x++;
+		if(c=='\n') break;
+	}
+	//次行先頭からcx2文字数分後ろにサーチ
+	x=0;
+	while(x<cx2){
+		if(ix>=bp->n){
+			if(bp->next==NULL) break; //バッファ最後の場合そこに移動
+			bp=bp->next;
+			ix=0;
+			continue;
+		}
+		if(bp->Buf[ix]=='\n') break; //改行コードの場合そこに移動
+		ix++;
+		x++;
+	}
+	cursorbp=bp;
+	cursorix=ix;
+	cx=x;
+	//画面下端でなければカーソルを1つ下に移動して終了
+	if(cy<EDITWIDTHY-1){
+		cy++;
+		return;
+	}
+	//下端の場合
+	//画面左上位置を更新
+	//改行コードまたは画面横幅超えるまでサーチ
+	bp=disptopbp;
+	ix=disptopix;
+	x=0;
+	while(x<EDITWIDTHX){
+		if(ix >= bp->n){
+			bp=bp->next;
+			ix=0;
+			continue;
+		}
+		if(bp->Buf[ix++]=='\n') break;
+		x++;
+	}
+	disptopbp=bp;
+	disptopix=ix;
+}
+void cursor_home(void){
+//カーソルを行先頭に移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cx2 0
+//cy 変更なし
+//disptopbp,disptopix 画面左上のバッファ上の位置（変更なし）
+
+	//カーソルX座標分前に移動
+	while(cx>0){
+		if(cursorix==0){
+			//空バッファは飛ばす
+			cursorbp=cursorbp->prev;
+			cursorix=cursorbp->n;
+			continue;
+		}
+		cursorix--;
+		cx--;
+	}
+	cx2=0;
+}
+void cursor_end(void){
+//カーソルを行末に移動
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cx2 行末
+//cy 変更なし
+//disptopbp,disptopix 画面左上のバッファ上の位置（変更なし）
+
+	//カーソルX座標を画面幅分後ろに移動
+	//改行コードまたはバッファ最終があればそこに移動
+	while(cx<EDITWIDTHX-1){
+		if(cursorix>=cursorbp->n){
+			//空バッファは飛ばす
+			if(cursorbp->next==NULL) break;
+			cursorbp=cursorbp->next;
+			cursorix=0;
+			continue;
+		}
+		if(cursorbp->Buf[cursorix]=='\n') break;
+		cursorix++;
+		cx++;
+	}
+	cx2=cx;
+}
+void cursor_pageup(void){
+//PageUpキー
+//最上行が最下行になるまでスクロール
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cx2
+//cy
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int i;
+	int cy_old;
+
+	cy_old=cy;
+	while(cy>0) cursor_up(); // cy==0になるまでカーソルを上に移動
+	for(i=0;i<EDITWIDTHY-1;i++){
+		//画面行数-1行分カーソルを上に移動
+		bp=disptopbp;
+		ix=disptopix;
+		cursor_up();
+		if(bp==disptopbp && ix==disptopix) break; //最上行で移動できなかった場合抜ける
+	}
+	//元のY座標までカーソルを下に移動、1行も動かなかった場合は最上行に留まる
+	if(i>0) while(cy<cy_old) cursor_down();
+}
+void cursor_pagedown(void){
+//PageDownキー
+//最下行が最上行になるまでスクロール
+//出力：下記変数を移動先の値に変更
+//cursorbp,cursorix バッファ上のカーソル位置
+//cx,cx2
+//cy
+//disptopbp,disptopix 画面左上のバッファ上の位置
+
+	_tbuf *bp;
+	int ix;
+	int i;
+	int y;
+	int cy_old;
+
+	cy_old=cy;
+	while(cy<EDITWIDTHY-1){
+		// cy==EDITWIDTH-1になるまでカーソルを下に移動
+		y=cy;
+		cursor_down();
+		if(y==cy) break;// バッファ最下行で移動できなかった場合抜ける
+	}
+	for(i=0;i<EDITWIDTHY-1;i++){
+		//画面行数-1行分カーソルを下に移動
+		bp=disptopbp;
+		ix=disptopix;
+		cursor_down();
+		if(bp==disptopbp && ix==disptopix) break; //最下行で移動できなかった場合抜ける
+	}
+	//下端からさらに移動した行数分、カーソルを上に移動、1行も動かなかった場合は最下行に留まる
+	if(i>0) while(cy>cy_old) cursor_up();
+}
+void cursor_top(void){
+//カーソルをテキストバッファの先頭に移動
+	cursorbp=TBufstart;
+	cursorix=0;
+	cursorbp1=NULL; //範囲選択モード解除
+	disptopbp=cursorbp;
+	disptopix=cursorix;
+	cx=0;
+	cx2=0;
+	cy=0;
+}
+
+int countarea(void){
+//テキストバッファの指定範囲の文字数をカウント
+//範囲は(cursorbp,cursorix)と(cursorbp1,cursorix1)で指定
+//後ろ側の一つ前の文字までをカウント
+	_tbuf *bp1,*bp2;
+	int ix1,ix2;
+	int n;
+
+	//範囲選択モードの場合、開始位置と終了の前後判断して
+	//bp1,ix1を開始位置、bp2,ix2を終了位置に設定
+	if(cy<cy1 || (cy==cy1 && cx<cx1)){
+		bp1=cursorbp;
+		ix1=cursorix;
+		bp2=cursorbp1;
+		ix2=cursorix1;
+	}
+	else{
+		bp1=cursorbp1;
+		ix1=cursorix1;
+		bp2=cursorbp;
+		ix2=cursorix;
+	}
+	n=0;
+	while(1){
+		if(bp1==bp2 && ix1==ix2) return n;
+		if(ix1 < bp1->n){
+			n++;
+			ix1++;
+		}
+		else{
+			bp1=bp1->next;
+			ix1=0;
+		}
+	}
+}
+void deletearea(void){
+//テキストバッファの指定範囲を削除
+//範囲は(cursorbp,cursorix)と(cursorbp1,cursorix1)で指定
+//後ろ側の一つ前の文字までを削除
+//削除後のカーソル位置は選択範囲の先頭にし、範囲選択モード解除する
+
+	_tbuf *bp;
+	int ix;
+	int n;
+
+	n=countarea(); //選択範囲の文字数カウント
+
+	//範囲選択の開始位置と終了位置の前後を判断してカーソルを開始位置に設定
+	if(cy>cy1 || (cy==cy1 && cx>cx1)){
+		cursorbp=cursorbp1;
+		cursorix=cursorix1;
+		cx=cx1;
+		cy=cy1;
+	}
+	cx2=cx;
+	cursorbp1=NULL; //範囲選択モード解除
+
+	//bp,ixを開始位置に設定
+	bp=cursorbp;
+	ix=cursorix;
+
+	//選択範囲が最初のバッファの最後まである場合
+	if(n>=(bp->n - ix)){
+		n -= bp->n - ix; //削除文字数減
+		num-=bp->n - ix; //バッファ使用量を減数
+		bp->n=ix; //ix以降を削除
+		bp=bp->next;
+		if(bp==NULL) return;
+		ix=0;
+	}
+	//次のバッファ以降、選択範囲の終了位置が含まれないバッファは削除
+	while(n>=bp->n){
+		n-=bp->n; //削除文字数減
+		num-=bp->n; //バッファ使用量を減数
+		bp=deleteTBuf(bp); //バッファ削除して次のバッファに進む
+		if(bp==NULL) return;
+	}
+	//選択範囲の終了位置を含む場合、1文字ずつ削除
+	while(n>0){
+		deletechar(bp,ix); //バッファから1文字削除（numは関数内で1減される）
+		n--;
+	}
+}
+void clipcopy(void){
+// 選択範囲をクリップボードにコピー
+	_tbuf *bp1,*bp2;
+	int ix1,ix2;
+	char *ps,*pd;
+
+	//範囲選択モードの場合、開始位置と終了の前後判断して
+	//bp1,ix1を開始位置、bp2,ix2を終了位置に設定
+	if(cy<cy1 || (cy==cy1 && cx<cx1)){
+		bp1=cursorbp;
+		ix1=cursorix;
+		bp2=cursorbp1;
+		ix2=cursorix1;
+	}
+	else{
+		bp1=cursorbp1;
+		ix1=cursorix1;
+		bp2=cursorbp;
+		ix2=cursorix;
+	}
+	ps=bp1->Buf+ix1;
+	pd=clipboard;
+	clipsize=0;
+	while(bp1!=bp2 || ix1!=ix2){
+		if(ix1 < bp1->n){
+			*pd++=*ps++;
+			clipsize++;
+			ix1++;
+		}
+		else{
+			bp1=bp1->next;
+			ps=bp1->Buf;
+			ix1=0;
+		}
+	}
+}
+void clippaste(void){
+// クリップボードから貼り付け
+	int n,i;
+	unsigned char *p;
+
+	p=clipboard;
+	for(n=clipsize;n>0;n--){
+		i=insertchar(cursorbp,cursorix,*p);
+		if(i>0){
+			//バッファ空きがあるのに挿入失敗の場合
+			gabagecollect2(); //全体ガベージコレクション
+			i=insertchar(cursorbp,cursorix,*p);//テキストバッファに１文字挿入
+		}
+		if(i!=0) return;//挿入失敗
+		cursor_right();//画面上、バッファ上のカーソル位置を1つ後ろに移動
+		p++;
+	}
+}
+void set_areamode(){
+//範囲選択モード開始時のカーソル開始位置グローバル変数設定
+	cursorbp1=cursorbp;
+	cursorix1=cursorix;
+	cx1=cx;
+	cy1=cy;
+}
+void save_cursor(void){
+//カーソル関連グローバル変数を一時避難
+	cursorbp_t=cursorbp;
+	cursorix_t=cursorix;
+	disptopbp_t=disptopbp;
+	disptopix_t=disptopix;
+	cx_t=cx;
+	cy_t=cy;
+}
+void restore_cursor(void){
+//カーソル関連グローバル変数を一時避難場所から戻す
+	cursorbp=cursorbp_t;
+	cursorix=cursorix_t;
+	disptopbp=disptopbp_t;
+	disptopix=disptopix_t;
+	cx=cx_t;
+	cy=cy_t;
+}
+
+int filesystemretry(){
+// SDファイルシステムの再初期化確認と実施
+// SDファイルへの保存や読み込み時にファイルエラーが発生した場合に呼び出す
+// 戻り値　0：初期化成功、-1：成功することなくEscapeで抜けた
+	unsigned short vk;
+	while(1){
+		setcursorcolor(COLOR_NORMALTEXT);
+		printstr((unsigned char *)Message3); //Retry / Quit
+		while(1){
+			inputchar(); //1文字入力待ち
+			vk=vkey & 0xff;
+			if(vk==VK_RETURN || vk==VK_SEPARATOR) break;
+			if(vk==VK_ESCAPE) return -1;
+		}
+		//ファイルシステム初期化
+		if(FSInit()!=FALSE) return 0; //成功
+		//エラーの場合
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr((unsigned char *)Message2);//File System Error
+	}
+}
+
+int sdfilecopy(char *sourcefile,char *distfile){
+// SDカード上のファイルをコピー
+// soucefile:コピー元ファイル名
+// distfile:コピー先ファイル名
+// 戻り値：正常終了 0、エラー終了時エラー番号
+	FSFILE *sfp,*dfp;
+	int n,er,c;
+	er=0;
+	sfp=FSfopen(sourcefile,"r");
+	if(sfp==NULL) return ERR_CANTFILEOPEN;
+	dfp=FSfopen(distfile,"w");
+	if(dfp==NULL){
+		FSfclose(sfp);
+		return ERR_CANTFILEOPEN;
+	}
+	c=0;
+	while(1){
+		if(c==0){
+			printchar('.');
+			c=100;
+		}
+		c--;
+		n=FSfread(filebuf,1,FILEBUFSIZE,sfp);
+		if(n==0) break;
+		if(FSfwrite(filebuf,1,n,dfp)!=n){
+			er=ERR_CANTWRITEFILE;
+			break;
+		}
+	}
+	FSfclose(sfp);
+	FSfclose(dfp);
+	return er;
+}
+int savetextfile(char *filename){
+// テキストバッファをテキストファイルに書き込み
+// 書き込み成功で0、失敗でエラーコード（負数）を返す
+	FSFILE *fp;
+	_tbuf *bp;
+	int ix,n,i,er;
+	unsigned char *ps,*pd;
+	er=0;//エラーコード
+	i=-1;
+	fp=FSfopen(filename,"w");
+	if(fp==NULL) return ERR_CANTFILEOPEN;
+	bp=TBufstart;
+	ix=0;
+	ps=bp->Buf;
+	do{
+		pd=filebuf;
+		n=0;
+		while(n<FILEBUFSIZE-1){
+		//改行コードが2バイトになることを考慮してバッファサイズ-1までとする
+			while(ix>=bp->n){
+				bp=bp->next;
+				if(bp==NULL){
+					break;
+				}
+				ix=0;
+				ps=bp->Buf;
+			}
+			if(bp==NULL) break;
+			if(*ps=='\n'){
+				*pd++='\r'; //改行コード0A→0D 0Aにする
+				n++;
+			}
+			*pd++=*ps++;
+			ix++;
+			n++;
+		}
+		if(n>0){
+			i=FSfwrite(filebuf,1,n,fp);
+			if(i!=n) er=ERR_CANTWRITEFILE;
+		}
+	} while(bp!=NULL && er==0);
+	FSfclose(fp);
+	return er;
+}
+int loadtextfile(char *filename){
+// テキストファイルをテキストバッファに読み込み
+// 読み込み成功で0、失敗でエラーコード（負数）を返す
+	FSFILE *fp;
+	_tbuf *bp;
+	int ix,n,i,er;
+	unsigned char *ps,*pd;
+	er=0;//エラーコード
+	fp=FSfopen(filename,"r");
+	if(fp==NULL) return ERR_CANTFILEOPEN;
+	inittextbuf();
+	bp=TextBuffer;
+	ix=0;
+	pd=bp->Buf;
+	do{
+		n=FSfread(filebuf,1,FILEBUFSIZE,fp);
+		ps=filebuf;
+		for(i=0;i<n;i++){
+			if(ix>=TBUFSIZE){
+				bp->n=TBUFSIZE;
+				bp=newTBuf(bp);
+				if(bp==NULL){
+					er=ERR_FILETOOBIG;
+					break;
+				}
+				ix=0;
+				pd=bp->Buf;
+			}
+			if(*ps=='\r') ps++; //改行コード0D 0A→0Aにする（単純に0D無視）
+			else{
+				*pd++=*ps++;
+				ix++;
+				num++;//バッファ総文字数
+				if(num>TBUFMAXSIZE){
+					er=ERR_FILETOOBIG;
+					break;
+				}
+			}
+		}
+	} while(n==FILEBUFSIZE && er==0);
+	if(bp!=NULL) bp->n=ix;//最後のバッファの文字数
+	FSfclose(fp);
+	if(er) inittextbuf();//エラー発生の場合バッファクリア
+	return er;
+}
+int overwritecheck(char *fn){
+// ファイルの上書き確認
+// ファイルの存在をチェックし、存在する場合キーボードから上書き確認する
+// fn:ファイル名へのポインタ
+// 戻り値　0：存在しないまたは上書き、-1：上書きしない
+	SearchRec sr;
+	unsigned short vk;
+	if(FindFirst(tempfile,ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_ARCHIVE,&sr)) return 0; //ファイルが存在しない
+	setcursorcolor(COLOR_ERRORTEXT);
+	printstr(tempfile);
+	printstr(": File Exists\n");
+	setcursorcolor(COLOR_NORMALTEXT);
+	printstr("Ovewrite:[Enter] / Stop:[ESC]\n");
+	while(1){
+		inputchar(); //1文字入力待ち
+		vk=vkey & 0xff;
+		if(vk==VK_RETURN || vk==VK_SEPARATOR) return 0;
+		if(vk==VK_ESCAPE) return -1;
+	}
+}
+void save_as(int ow){
+// 現在のテキストバッファの内容をSDカードに保存
+// ow　0:名前を付けて保存　　1:上書き保存
+// ファイル名はグローバル変数currentfile[]
+// ファイル名はキーボードから変更可能
+// 成功した場合currentfileを更新
+
+	int er;
+	unsigned char *ps,*pd;
+
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	printstr("Save To SD Card\n");
+	if(currentfile[0]==0) ow=0; //ファイル名が設定されていない場合名前を付けて保存
+
+	//currentfileからtempfileにコピー
+	ps=currentfile;
+	pd=tempfile;
+	while(*ps!=0) *pd++=*ps++;
+	*pd=0;
+
+	while(1){
+		if(ow==0){
+			printstr("File Name + [Enter] / [ESC]\n");
+			if(lineinput(tempfile,8+1+3)<0) return; //ESCキーが押された
+			if(tempfile[0]==0) continue; //NULL文字列の場合
+			if(overwritecheck(tempfile)) continue;
+		}
+		printstr("Writing...\n");
+		er=savetextfile(tempfile); //ファイル保存、er:エラーコード
+		if(er==0){
+			printstr("OK");
+			FSremove(TEMPFILENAME); //実行時に生成する一時ファイルを削除
+			//tempfileからcurrentfileにコピーして終了
+			ps=tempfile;
+			pd=currentfile;
+			while(*ps!=0) *pd++=*ps++;
+			*pd=0;
+			edited=0; //編集済みフラグクリア
+			wait60thsec(60);//1秒待ち
+			return;
+		}
+		setcursorcolor(COLOR_ERRORTEXT);
+		if(er==ERR_CANTFILEOPEN) printstr("Bad File Name or File Error\n");
+		else printstr("Cannot Write\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+}
+
+void msra(void){
+// Make Self-Running Application （自己実行アプリケーションの作成）
+// 最初にソースファイルを名前を付けて保存
+// 次にBASICシステムのHEXファイルをソースファイル名の拡張子をHEXにした名前でコピー
+
+	int er;
+	unsigned char vk;
+	unsigned char *ps,*pd;
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	printstr("Make Self-Running Application\n\n");
+
+	//currentfileからtempfileにコピー
+	ps=currentfile;
+	pd=tempfile;
+	while(*ps!=0) *pd++=*ps++;
+	*pd=0;
+
+	while(1){
+		setcursorcolor(COLOR_NORMALTEXT);
+		printstr("Input File Name (xxx.BAS)\n");
+		if(lineinput(tempfile,8+1+3)<0) return; //ESCキーが押された
+		ps=tempfile;
+		while(*ps!='.' && *ps!=0) ps++;
+		if(ps+4>=tempfile+13 ||
+			*ps!='.' ||
+			(*(ps+1)!='b' && *(ps+1)!='B') ||
+			(*(ps+2)!='a' && *(ps+2)!='A') ||
+			(*(ps+3)!='s' && *(ps+3)!='S') ||
+			*(ps+4)!=0){
+				setcursorcolor(COLOR_ERRORTEXT);
+				printstr("File Name Must Be xxx.BAS\n");
+				continue;
+		}
+		if(overwritecheck(tempfile)) continue;
+		printstr("Writing BASIC File\n");
+		er=savetextfile(tempfile); //ファイル保存、er:エラーコード
+		if(er==0) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		if(er==ERR_CANTFILEOPEN) printstr("Bad File Name or File Error\n");
+		else printstr("Cannot Write\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+	printstr("OK\n\n");
+	FSremove(TEMPFILENAME); //実行時に生成する一時ファイルを削除
+	//tempfileからcurrentfileにコピーして終了
+	ps=tempfile;
+	pd=currentfile;
+	while(*ps!=0) *pd++=*ps++;
+	*pd=0;
+	edited=0; //編集済みフラグクリア
+	// 拡張子をHEXにしてBASICシステムファイルをコピー
+	*(ps-3)='H';
+	*(ps-2)='E';
+	*(ps-1)='X';
+	if(overwritecheck(tempfile)) return;
+	printstr("Copying\n");
+	printstr(HEXFILE);
+	printstr(" To ");
+	printstr(tempfile);
+	printstr("\nWait For A While");
+	er=sdfilecopy(HEXFILE,tempfile);
+	if(er==0){
+		printstr("\nDone");
+		wait60thsec(120);//2秒待ち
+		return;
+	}
+	setcursorcolor(COLOR_ERRORTEXT);
+	if(er==ERR_CANTFILEOPEN){
+		printstr(HEXFILE);
+		printstr(" Not Found\n");
+	}
+	else if(er==ERR_CANTWRITEFILE){
+		printstr("Write Error\n");
+	}
+	setcursorcolor(COLOR_NORMALTEXT);
+	printstr((unsigned char *)Message1);// Hit Any Key
+	inputchar(); //1文字入力待ち
+	return;
+}
+
+int selectfile(void){
+// SDカードからファイルを選択して読み込み
+// currenfile[]にファイル名を記憶
+// 対象ファイル拡張子 BASおよびTXT
+// 戻り値　0：読み込みを行った　-1：読み込みなし
+	unsigned int filenum,top,f;
+	int er;
+	unsigned char *ps,*pd;
+	unsigned char x,y;
+	unsigned char vk;
+	SearchRec sr;
+
+	//ファイルの一覧をSDカードから読み出し
+	cls();
+	if(edited && num){
+		//最終保存後に編集済みの場合、保存の確認
+		setcursorcolor(COLOR_NORMALTEXT);
+		printstr("Save Program Before Load?\n");
+		printstr("Save:[Enter] / Not Save:[ESC]\n");
+		while(1){
+			inputchar(); //1文字キー入力待ち
+			vk=vkey & 0xff;
+			if(vk==VK_RETURN || vk==VK_SEPARATOR){
+				save_as(0); //名前を付けて保存
+				break;
+			}
+			else if(vk==VK_ESCAPE) break;
+		}
+	}
+	filenum=0;
+	while(1){
+		//拡張子 BASファイルのサーチ
+		if(FindFirst("*.BAS",ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_ARCHIVE,&sr)==0){
+			do{
+				//filenames[]にファイル名の一覧を読み込み
+				ps=sr.filename;
+				pd=filenames[filenum];
+				while(*ps!=0) *pd++=*ps++;
+				*pd=0;
+				filenum++;
+			}
+			while(!FindNext(&sr) && filenum<MAXFILENUM);
+		}
+		if(filenum>=MAXFILENUM) break;
+		//拡張子 TXTファイルのサーチ
+		if(FindFirst("*.TXT",ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_ARCHIVE,&sr)==0){
+			do{
+				//filenames[]にファイル名の一覧を読み込み
+				ps=sr.filename;
+				pd=filenames[filenum];
+				while(*ps!=0) *pd++=*ps++;
+				*pd=0;
+				filenum++;
+			}
+			while(!FindNext(&sr) && filenum<MAXFILENUM);
+		}
+		if(filenum>=MAXFILENUM) break;
+		//拡張子 INIファイルのサーチ
+		if(FindFirst("*.INI",ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_ARCHIVE,&sr)==0){
+			do{
+				//filenames[]にファイル名の一覧を読み込み
+				ps=sr.filename;
+				pd=filenames[filenum];
+				while(*ps!=0) *pd++=*ps++;
+				*pd=0;
+				filenum++;
+			}
+			while(!FindNext(&sr) && filenum<MAXFILENUM);
+		}
+		if(filenum>0) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr(".BAS or .TXT File Not Found\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+
+	//ファイル一覧を画面に表示
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	printstr("Load: ");
+	setcursorcolor(4);
+	printstr("Select&[Enter] / [ESC]\n");
+	for(f=0;f<filenum;f++){
+		x=(f&1)*15+1;
+		y=f/2+1;
+		if(y>=WIDTH_Y-1) break;
+		setcursor(x,y,COLOR_NORMALTEXT);
+		printstr(filenames[f]);
+	}
+
+	//ファイルの選択
+	top=0;//画面一番先頭のファイル番号
+	f=0;//現在選択中のファイル番号
+	setcursor(0,1,5);
+	printchar(0x1c); // Right Arrow
+	cursor--;
+	while(1){
+		inputchar();
+		vk=vkey & 0xff;
+		if(vk==0) continue;
+		printchar(' ');
+		setcursor(0,WIDTH_Y-1,COLOR_NORMALTEXT);
+		for(x=0;x<WIDTH_X-1;x++) printchar(' '); //最下行のステータス表示を消去
+		switch(vk){
+			case VK_UP:
+			case VK_NUMPAD8:
+				//上矢印キー
+				if(f>=2){
+					f-=2;
+					if(f<top){
+						//画面最上部の場合、下にスクロールして最上部にファイル名2つ表示
+						setcursor(WIDTH_X-1,WIDTH_Y-2,COLOR_NORMALTEXT);
+						while(cursor>=TVRAM+WIDTH_X*2){
+							*cursor=*(cursor-WIDTH_X);
+							*(cursor+ATTROFFSET)=*(cursor+ATTROFFSET-WIDTH_X);
+							cursor--;
+						}
+						while(cursor>=TVRAM+WIDTH_X) *cursor--=' ';
+						top-=2;
+						setcursor(1,1,COLOR_NORMALTEXT);
+						printstr(filenames[top]);
+						setcursor(16,1,COLOR_NORMALTEXT);
+						printstr(filenames[top+1]);
+					}
+				}
+				break;
+			case VK_DOWN:
+			case VK_NUMPAD2:
+				//下矢印キー
+				if(f+2<filenum){
+					f+=2;
+					if(f-top>=(WIDTH_Y-2)*2){
+						//画面最下部の場合、上にスクロールして最下部にファイル名1つor2つ表示
+						setcursor(0,1,COLOR_NORMALTEXT);
+						while(cursor<TVRAM+WIDTH_X*(WIDTH_Y-2)){
+							*cursor=*(cursor+WIDTH_X);
+							*(cursor+ATTROFFSET)=*(cursor+ATTROFFSET+WIDTH_X);
+							cursor++;
+						}
+						while(cursor<TVRAM+WIDTH_X*(WIDTH_Y-1)) *cursor++=' ';
+						top+=2;
+						setcursor(1,WIDTH_Y-2,COLOR_NORMALTEXT);
+						printstr(filenames[f&0xfffe]);
+						if((f|1)<filenum){
+							setcursor(16,WIDTH_Y-2,COLOR_NORMALTEXT);
+							printstr(filenames[f|1]);
+						}
+					}
+				}
+				break;
+			case VK_LEFT:
+			case VK_NUMPAD4:
+				//左矢印キー
+				if(f&1) f--;
+				break;
+			case VK_RIGHT:
+			case VK_NUMPAD6:
+				//右矢印キー
+				if((f&1)==0 && f+1<filenum) f++;
+				break;
+			case VK_RETURN: //Enterキー
+			case VK_SEPARATOR: //テンキーのEnter
+				//ファイル名決定。読み込んで終了
+				er=loadtextfile(filenames[f]); //テキストバッファにファイル読み込み
+				if(er==0){
+					//currenfile[]変数にファイル名をコピーして終了
+					ps=filenames[f];
+					pd=currentfile;
+					while(*ps!=0) *pd++=*ps++;
+					*pd=0;
+					return 0;
+				}
+				setcursor(0,WIDTH_Y-1,COLOR_ERRORTEXT);
+				if(er==ERR_CANTFILEOPEN) printstr("Cannot Open File");
+				else if(er=ERR_FILETOOBIG) printstr("File Too Big");
+				break;
+			case VK_ESCAPE:
+				//ESCキー、ファイル読み込みせず終了
+				return -1;
+		}
+		setcursor((f&1)*15,(f-top)/2+1,5);
+		printchar(0x1c);// Right Arrow
+		cursor--;
+	}
+}
+void newtext(void){
+// 新規テキスト作成
+	unsigned char vk;
+	if(edited && num){
+		//最終保存後に編集済みの場合、保存の確認
+		cls();
+		setcursorcolor(COLOR_NORMALTEXT);
+		printstr("Save Editing File?\n");
+		printstr("Save:[Enter] / Not Save:[ESC]\n");
+		while(1){
+			inputchar(); //1文字キー入力待ち
+			vk=vkey & 0xff;
+			if(vk==VK_RETURN || vk==VK_SEPARATOR){
+				save_as(0); //名前を付けて保存
+				break;
+			}
+			else if(vk==VK_ESCAPE) break;
+		}
+	}
+	inittextbuf(); //テキストバッファ初期化
+	cursor_top(); //カーソルをテキストバッファの先頭に設定
+	currentfile[0]=0; //作業中ファイル名クリア
+}
+void run(int test){
+//KM-BASICコンパイル＆実行
+// test 0:コンパイルと実行、0以外:コンパイルのみで終了
+	int er,er2;
+	unsigned char vk;
+	unsigned int disptoppos,cursorpos;
+	int i,edited1;
+	_tbuf *bp;
+	unsigned short ix;
+
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	while(1){
+		er=savetextfile(TEMPFILENAME); //一時ファイルに保存、er:エラーコード
+		if(er==0) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Write To SD Card\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+
+	//カーソル位置、画面表示位置の保存
+	disptoppos=bpixtopos(disptopbp,disptopix);
+	cursorpos=bpixtopos(cursorbp,cursorix);
+	edited1=edited; //編集済みフラグの一時退避
+	// Enable Break key
+	g_disable_break=0;
+	//KM-BASIC実行
+	er2=runbasic(TEMPFILENAME,test);
+
+	stopPCG();//システムフォントに戻す
+	setcursorcolor(COLOR_NORMALTEXT);
+	printchar('\n');
+	printstr((unsigned char *)Message1);// Hit Any Key
+	do ps2readkey(); //キーバッファが空になるまで読み出し
+	while(vkey!=0);
+	ps2mode(); //キーボード有効化
+	inputchar(); //1文字入力待ち
+	init_composite(); //パレット初期化のため画面初期化
+	while(1){
+		er=loadtextfile(TEMPFILENAME); //一時ファイルから戻す
+		if(er==0) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Load From SD Card\n");
+		filesystemretry(); //ファイルシステム再初期化
+	}
+	if(er2<=0){
+		//正常終了またはファイルエラーまたはリンクエラーの場合
+		//カーソルを元の位置に設定
+		disptopbp=postobpix(disptoppos,&disptopix);
+		cursorbp=postobpix(cursorpos,&cursorix);
+	}
+	else{
+		//コンパイルエラーの場合
+		//カーソルをエラー行で画面トップに移動
+		disptopbp=linetobpix(er2,&disptopix);
+		cursorbp=disptopbp;
+		cursorix=disptopix;
+		cx=0;
+		cx2=0;
+		cy=0;
+		//中央になるようスクロール
+		for(i=0;i<EDITWIDTHY/2;i++){
+			//画面行数半分カーソルを上に移動
+			bp=disptopbp;
+			ix=disptopix;
+			cursor_up();
+			if(bp==disptopbp && ix==disptopix) break; //最上行で移動できなかった場合抜ける
+		}
+		for(;i>0;i--) cursor_down(); //元のY座標までカーソルを下に移動
+	}
+	cursorbp1=NULL; //範囲選択モード解除
+	clipsize=0; //クリップボードクリア
+	edited=edited1;
+	FSremove(TEMPFILENAME); //一時ファイル削除
+}
+void displaybottomline(void){
+//エディター画面最下行の表示
+	unsigned char *p;
+	unsigned char c;
+	p=cursor; //カーソル位置の退避
+	c=cursorcolor;
+	setcursor(0,WIDTH_Y-1,COLOR_BOTTOMLINE);
+	if(shiftkeys() & CHK_SHIFT)
+		printstr("NEW |MSRA|    |TEST|     ");
+	else
+		printstr("LOAD|SAVE|    |RUN |     ");
+	setcursorcolor(COLOR_ERRORTEXT);
+	printnum2(TBUFMAXSIZE-num,5);
+	cursor=p; //カーソル位置戻し
+	cursorcolor=c;
+}
+void normal_code_process(unsigned char k){
+// 通常文字入力処理
+// k:入力された文字コード
+	int i;
+
+	edited=1; //編集済みフラグ
+	if(insertmode || k=='\n' || cursorbp1!=NULL){ //挿入モード
+		if(cursorbp1!=NULL) deletearea();//選択範囲を削除
+		i=insertchar(cursorbp,cursorix,k);//テキストバッファに１文字挿入
+		if(i>0){
+			//バッファ空きがあるのに挿入失敗の場合
+			gabagecollect2(); //全体ガベージコレクション
+			i=insertchar(cursorbp,cursorix,k);//テキストバッファに１文字挿入
+		}
+		if(i==0) cursor_right();//画面上、バッファ上のカーソル位置を1つ後ろに移動
+	}
+	else{ //上書きモード
+		i=overwritechar(cursorbp,cursorix,k);//テキストバッファに１文字上書き
+		if(i>0){
+			//バッファ空きがあるのに上書き（挿入）失敗の場合
+			//（行末やバッファ最後尾では挿入）
+			gabagecollect2(); //全体ガベージコレクション
+			i=overwritechar(cursorbp,cursorix,k);//テキストバッファに１文字上書き
+		}
+		if(i==0) cursor_right();//画面上、バッファ上のカーソル位置を1つ後ろに移動
+	}
+}
+void control_code_process(unsigned char k,unsigned char sh){
+// 制御文字入力処理
+// k:制御文字の仮想キーコード
+// sh:シフト関連キー状態
+
+	save_cursor(); //カーソル関連変数退避（カーソル移動できなかった場合戻すため）
+	switch(k){
+		case VK_LEFT:
+		case VK_NUMPAD4:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD4) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			if(sh & CHK_CTRL){
+				//CTRL＋左矢印でHome
+				cursor_home();
+				break;
+			}
+			cursor_left();
+			if(cursorbp1!=NULL && (disptopbp!=disptopbp_t || disptopix!=disptopix_t)){
+				//範囲選択モードで画面スクロールがあった場合
+				if(cy1<EDITWIDTHY-1) cy1++; //範囲スタート位置もスクロール
+				else restore_cursor(); //カーソル位置を戻す（画面範囲外の範囲選択禁止）
+			}
+			break;
+		case VK_RIGHT:
+		case VK_NUMPAD6:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD6) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			if(sh & CHK_CTRL){
+				//CTRL＋右矢印でEnd
+				cursor_end();
+				break;
+			}
+			cursor_right();
+			if(cursorbp1!=NULL && (disptopbp!=disptopbp_t || disptopix!=disptopix_t)){
+				//範囲選択モードで画面スクロールがあった場合
+				if(cy1>0) cy1--; //範囲スタート位置もスクロール
+				else restore_cursor(); //カーソル位置を戻す（画面範囲外の範囲選択禁止）
+			}
+			break;
+		case VK_UP:
+		case VK_NUMPAD8:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD8) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			cursor_up();
+			if(cursorbp1!=NULL && (disptopbp!=disptopbp_t || disptopix!=disptopix_t)){
+				//範囲選択モードで画面スクロールがあった場合
+				if(cy1<EDITWIDTHY-1) cy1++; //範囲スタート位置もスクロール
+				else restore_cursor(); //カーソル位置を戻す（画面範囲外の範囲選択禁止）
+			}
+			break;
+		case VK_DOWN:
+		case VK_NUMPAD2:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD2) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			cursor_down();
+			if(cursorbp1!=NULL && (disptopbp!=disptopbp_t || disptopix!=disptopix_t)){
+				//範囲選択モードで画面スクロールがあった場合
+				if(cy1>0) cy1--; //範囲スタート位置もスクロール
+				else restore_cursor(); //カーソル位置を戻す（画面範囲外の範囲選択禁止）
+			}
+			break;
+		case VK_HOME:
+		case VK_NUMPAD7:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD7) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			cursor_home();
+			break;
+		case VK_END:
+		case VK_NUMPAD1:
+			 //シフトキー押下していなければ範囲選択モード解除（NumLock＋シフト＋テンキーでも解除）
+			if((sh & CHK_SHIFT)==0 || (k==VK_NUMPAD1) && (sh & CHK_NUMLK)) cursorbp1=NULL;
+			else if(cursorbp1==NULL) set_areamode(); //範囲選択モードでなければ範囲選択モード開始
+			cursor_end();
+			break;
+		case VK_PRIOR: // PageUpキー
+		case VK_NUMPAD9:
+			 //シフト＋PageUpは無効（NumLock＋シフト＋「9」除く）
+			if((sh & CHK_SHIFT) && ((k!=VK_NUMPAD9) || ((sh & CHK_NUMLK)==0))) break;
+			cursorbp1=NULL; //範囲選択モード解除
+			cursor_pageup();
+			break;
+		case VK_NEXT: // PageDownキー
+		case VK_NUMPAD3:
+			 //シフト＋PageDownは無効（NumLock＋シフト＋「3」除く）
+			if((sh & CHK_SHIFT) && ((k!=VK_NUMPAD3) || ((sh & CHK_NUMLK)==0))) break;
+			cursorbp1=NULL; //範囲選択モード解除
+			cursor_pagedown();
+			break;
+		case VK_DELETE: //Deleteキー
+		case VK_DECIMAL: //テンキーの「.」
+			edited=1; //編集済みフラグ
+			if(cursorbp1!=NULL) deletearea();//選択範囲を削除
+			else deletechar(cursorbp,cursorix);
+			break;
+		case VK_BACK: //BackSpaceキー
+			edited=1; //編集済みフラグ
+			if(cursorbp1!=NULL){
+				deletearea();//選択範囲を削除
+				break;
+			}
+			if(cursorix==0 && cursorbp->prev==NULL) break; //バッファ先頭では無視
+			cursor_left();
+			deletechar(cursorbp,cursorix);
+			break;
+		case VK_INSERT:
+		case VK_NUMPAD0:
+			insertmode^=1; //挿入モード、上書きモードを切り替え
+			break;
+		case 'C':
+			//CTRL+C、クリップボードにコピー
+			if(cursorbp1!=NULL && (sh & CHK_CTRL)) clipcopy();
+			break;
+		case 'X':
+			//CTRL+X、クリップボードに切り取り
+			if(cursorbp1!=NULL && (sh & CHK_CTRL)){
+				clipcopy();
+				deletearea(); //選択範囲の削除
+				edited=1; //編集済みフラグ
+			}
+			break;
+		case 'V':
+			//CTRL+V、クリップボードから貼り付け
+			if((sh & CHK_CTRL)==0) break;
+			if(clipsize==0) break;
+			edited=1; //編集済みフラグ
+			if(cursorbp1!=NULL){
+				//範囲選択している時は削除してから貼り付け
+				if(num-countarea()+clipsize<=TBUFMAXSIZE){ //バッファ空き容量チェック
+					deletearea();//選択範囲を削除
+					clippaste();//クリップボード貼り付け
+				}
+			}
+			else{
+				if(num+clipsize<=TBUFMAXSIZE){ //バッファ空き容量チェック
+					clippaste();//クリップボード貼り付け
+				}
+			}
+			break;
+		case 'S':
+			//CTRL+S、SDカードに保存
+			if(num==0) break;
+			if(sh & CHK_CTRL) save_as(1); //上書き保存
+			break;
+		case 'O':
+			//CTRL+O、ファイル読み込み
+			if(sh & CHK_CTRL){
+				if(selectfile()==0){ //ファイルを選択して読み込み
+					//読み込みを行った場合、カーソル位置を先頭に
+					cursor_top();
+				}
+			}
+			break;
+		case 'N':
+			//CTRL+N、新規作成
+			if(sh & CHK_CTRL) newtext();
+			break;
+		case VK_F1: //F1キー
+			if(sh & CHK_SHIFT) newtext();//SHIFT+F1キー　新規作成
+			else{
+				//ファイル読み込み
+				if(selectfile()==0){ //ファイルを選択して読み込み
+					//読み込みを行った場合、カーソル位置を先頭に
+					cursor_top();
+				}
+			}
+			break;
+		case VK_F2: //F2キー
+			if(num==0) break;
+			if(sh & CHK_SHIFT) msra(); //create direct running file
+			else save_as(0); //ファイル名を付けて保存
+			break;
+		case VK_F4: //F4キー
+			if(num==0) break;
+			if(sh & CHK_SHIFT) run(1); //コンパイルテスト
+			else run(0); //コンパイル＆実行
+			break;
+	}
+}
+void texteditor(void){
+//テキストエディター本体
+	unsigned char k1,k2,k3,sh;
+
+	TextBuffer=(_tbuf *)RAM;
+	clipboard=(unsigned char *)TextBuffer+sizeof(_tbuf)*TBUFMAXLINE;
+	filebuf=clipboard+EDITWIDTHX*EDITWIDTHY;
+	filenames=(unsigned char (*)[])(filebuf+FILEBUFSIZE);
+
+	inittextbuf(); //テキストバッファ初期化
+	currentfile[0]=0; //作業中ファイル名クリア
+
+	//実行時生成一時ファイルがあった場合は読み込む
+	if(loadtextfile(TEMPFILENAME)==0){
+		edited=1;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Temporary File Loaded\n");
+		printstr("Save To SD Card If Necessary\n");
+		setcursorcolor(COLOR_NORMALTEXT);
+		printstr((unsigned char *)Message1); //Hit Any Key
+		inputchar(); //1文字入力待ち
+	}
+	cursor_top(); //カーソルをテキストバッファの先頭に移動
+	insertmode=1; //0:上書き、1:挿入
+	clipsize=0; //クリップボードクリア
+	blinktimer=0; //カーソル点滅タイマークリア
+
+	while(1){
+		redraw();//画面再描画
+		setcursor(cx,cy,COLOR_NORMALTEXT);
+		getcursorchar(); //カーソル位置の文字を退避（カーソル点滅用）
+		while(1){
+			//キー入力待ちループ
+			wait60thsec(1);  //60分の1秒ウェイト
+			blinkcursorchar(); //カーソル点滅させる
+			k1=ps2readkey(); //キーバッファから読み込み、k1:通常文字入力の場合ASCIIコード
+			displaybottomline(); //画面最下行にファンクションキー機能表示
+			if(vkey) break;  //キーが押された場合ループから抜ける
+			if(cursorbp1==NULL) gabagecollect1(); //1バイトガベージコレクション（範囲選択時はしない）
+		}
+		resetcursorchar(); //カーソルを元の文字表示に戻す
+		k2=(unsigned char)vkey; //k2:仮想キーコード
+		sh=vkey>>8;             //sh:シフト関連キー状態
+		if(k2==VK_RETURN || k2==VK_SEPARATOR) k1='\n'; //Enter押下は単純に改行文字を入力とする
+		if(k1) normal_code_process(k1); //通常文字が入力された場合
+		else control_code_process(k2,sh); //制御文字が入力された場合
+		if(cursorbp1!=NULL && cx==cx1 && cy==cy1) cursorbp1=NULL;//選択範囲の開始と終了が重なったら範囲選択モード解除
+ 	}
+}

--- mips/tags/zoea1.00/main.h	(nonexistent)
+++ mips/tags/zoea1.00/main.h	(revision 148)
@@ -0,0 +1,21 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#define SYSVER1 "Zoea"
+#define SYSVER2 "1.0"
+#define BASVER "KM-1200"
+
+#define INIFILE "MACHIKAZ.INI" // 初期設定ファイル
+#define HEXFILE "MACHIKAZ.HEX" // 実行中HEXファイル名がこれと一致した場合はエディタ起動
+
+#define FILENAME_FLASH_ADDRESS 0x9D005800
+#define PIC32MX_RAMSIZE 0x10000
+#define PIC32MX_FLASHSIZE 0x40000
+
+void printhex8(unsigned char d);
+void printhex16(unsigned short d);
+void printhex32(unsigned int d);

--- mips/tags/zoea1.00/editor.h	(nonexistent)
+++ mips/tags/zoea1.00/editor.h	(revision 148)
@@ -0,0 +1,29 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+
+#define TBUFMAXLINE 201 //テキストバッファ数
+
+#define TBUFSIZE 200 //テキストバッファ1つのサイズ
+#define TBUFMAXSIZE (TBUFSIZE*(TBUFMAXLINE-1)) //最大バッファ容量（バッファ1行分空ける）
+#define EDITWIDTHX 30 //エディタ画面横幅
+#define EDITWIDTHY 26 //エディタ画面縦幅
+#define COLOR_NORMALTEXT 7 //通常テキスト色
+#define COLOR_ERRORTEXT 4 //エラーメッセージテキスト色
+#define COLOR_AREASELECTTEXT 4 //範囲選択テキスト色
+#define COLOR_BOTTOMLINE 5 //画面最下行の色
+#define FILEBUFSIZE 256 //ファイルアクセス用バッファサイズ
+#define MAXFILENUM 200 //利用可能ファイル最大数
+
+#define ERR_FILETOOBIG -1
+#define ERR_CANTFILEOPEN -2
+#define ERR_CANTWRITEFILE -3
+
+#define TEMPFILENAME "~TEMP.BAS"
+
+void texteditor(void); //テキストエディタ本体
+int runbasic(char *s,int test); //コンパイルして実行
+extern unsigned char tempfile[13];
+void wait60thsec(unsigned short n);

--- mips/tags/zoea1.00/debug.c	(nonexistent)
+++ mips/tags/zoea1.00/debug.c	(revision 148)
@@ -0,0 +1,160 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#ifdef __DEBUG
+
+#include <xc.h>
+#include "api.h"
+#include "main.h"
+
+
+// Pseudo reading config setting for debug mode
+unsigned int g_DEVCFG1=0xFF7F4DDB;
+
+// Construct jump assembly in boot area.
+const unsigned int _debug_boot[] __attribute__((address(0xBFC00000))) ={
+	0x0B401C00,//   j           0x9d007000
+	0x00000000,//   nop         
+};
+
+// Use DEBUG.HEX as file name of this program.
+const unsigned char _debug_filename[] __attribute__((address(FILENAME_FLASH_ADDRESS))) ="DEBUG.HEX";
+
+static const char initext[];
+static const char bastext[];
+
+static char* readtext;
+static int filepos;
+
+/*
+    Override libsdfsio functions.
+    Here, don't use SD card, but the vertual files 
+    (initext[] and bastext[]) are used. 
+*/
+
+FSFILE fsfile;
+
+size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream){
+	char b;
+	size_t ret=0;
+	if (!readtext) return 0;
+	while(b=readtext[filepos]){
+		filepos++;
+		((char*)ptr)[ret]=b;
+		ret++;
+		if (n<=ret) break;
+	}
+	return ret;
+}
+FSFILE* FSfopen(const char * fileName, const char *mode){
+	int i;
+	for(i=0;i<13;i++){
+		if (fileName[i]=='.') break;
+	}
+	if (i==13) {
+		// Unknown file name
+		// Force BAS file
+		readtext=(char*)&bastext[0];
+	} else if (fileName[i+1]=='I' && fileName[i+2]=='N' && fileName[i+3]=='I') {
+		// INI file
+		readtext=(char*)&initext[0];
+	} else if (fileName[i+1]=='B' && fileName[i+2]=='A' && fileName[i+3]=='S') {
+		// BAS file
+		readtext=(char*)&bastext[0];
+	} else {
+		readtext=0;
+		return 0;
+	}
+	filepos=0;
+	return &fsfile;
+}
+int FSfeof( FSFILE * stream ){
+	return readtext[filepos]?1:0;
+}
+int FSfclose(FSFILE *fo){
+	return 0;
+}
+int FSInit(void){
+	return 1;
+}
+int FSremove (const char * fileName){
+	return 0;
+}
+size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream){
+	return 0;
+}
+
+int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec){
+	return 0;
+}
+int FindNext (SearchRec * rec){
+	return 0;
+}
+
+/*
+    ps2init() is not called.
+    Instead, not_ps2init_but_init_Timer1() is called.
+    Timer1 is used to update drawcount and drawing gloval variables.
+*/
+
+int not_ps2init_but_init_Timer1(){
+	PR1=0x0FFF;
+	TMR1=0;
+	IFS0bits.T1IF=0;
+	T1CON=0x8000;
+	// Timer1 interrupt: priority 4
+	IPC1bits.T1IP=4;
+	IPC1bits.T1IS=0;
+	IEC0bits.T1IE=1;
+
+	return 0;
+}
+
+#pragma interrupt timer1Int IPL4SOFT vector 4
+
+void timer1Int(){
+	IFS0bits.T1IF=0;
+	if (drawing) {
+		drawing=0;
+		drawcount++;
+	} else {
+		drawing=1;
+	}
+}
+
+/*
+    initext[] and bastext[] are vertual files 
+    as "MACHIKAN.INI" and "DEBUG.BAS".
+*/
+
+
+static const char initext[]=
+"#PRINT\n"
+"#PRINT\n";
+
+
+static const char bastext[]=
+"CLS\n"
+"\n";
+
+/*
+    Test function for constructing assemblies from C codes.
+*/
+
+int _debug_test(int a0, int a1){
+//	if (a0<0xa0008192) return 0xa0000000;
+	asm volatile("lw $v1,0($v1)");
+}
+
+/*
+	Break point used for debugging object code.
+
+g_object[g_objpos++]=0x0000000d;// break 0x0
+
+*/
+
+#endif // __DEBUG

--- mips/tags/zoea1.00/library.c	(nonexistent)
+++ mips/tags/zoea1.00/library.c	(revision 148)
@@ -0,0 +1,984 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include <xc.h>
+#include "main.h"
+#include "compiler.h"
+#include "api.h"
+#include "keyinput.h"
+#include "stdlib.h"
+#include "math.h"
+
+/*
+   Local global variables used for graphic
+ */
+
+static int g_gcolor=7;
+static int g_prev_x=0;
+static int g_prev_y=0;
+
+int lib_read(int mode, unsigned int label){
+	unsigned int i,code,code2;
+	static unsigned int pos=0;
+	static unsigned int in_data=0;
+	static unsigned char skip=0;
+	if (label) {
+		// RESTORE function
+		switch(mode){
+			case 0:
+				// label is label data
+				i=(int)search_label(label);
+				if (!i) {
+					err_data_not_found();
+					return 0;
+				}
+				break;
+			case 1:
+				// label is pointer
+				i=label;
+				break;
+			case 2:
+			default:
+				// Reset data/read
+				pos=0;
+				in_data=0;
+				skip=0;
+				return 0;
+		}
+		i-=(int)(&g_object[0]);
+		pos=i/4;
+		in_data=0;
+	}
+	// Get data
+	if (in_data==0) {
+		for(i=pos;i<g_objpos;i++){
+			code=g_object[i];
+			code2=g_object[i+1];
+			if ((code&0xFFFF0000)!=0x04110000) continue;
+			// "bgezal zero," assembly found.
+			// Check if 0x00000020,0x00000021,0x00000022, or 0x00000023 follows
+			if ((code2&0xfffffffc)!=0x00000020) {// add/addu/sub/subu        zero,zero,zero
+				// If not, skip following block (it's strig).
+				i+=code&0x0000FFFF;
+				i--;
+				continue;
+			}
+			// DATA region found.
+			in_data=(code&0x0000FFFF)-1;
+			pos=i+2;
+			skip=code2&0x03;
+			break;
+		}
+		if (g_objpos<=i) {
+			err_data_not_found();
+			return 0;
+		}
+	}
+	if (label) {
+		// RESTORE function. Return pointer.
+		return ((int)&g_object[pos])+skip;
+	} else {
+		switch(mode){
+			case 0:
+				// READ() function
+				in_data--;
+				return g_object[pos++];
+			case 1:
+			default:
+				// CREAD() function
+				i=g_object[pos];
+				i>>=skip*8;
+				i&=0xff;
+				if ((++skip)==4) {
+					skip=0;
+					in_data--;
+					pos++;
+				}
+				return i;
+		}
+	}
+}
+
+void reset_dataread(){
+	lib_read(2,1);
+}
+
+char* lib_midstr(int var_num, int pos, int len){
+	int i;
+	char* str;
+	char* ret;
+	if (0<=pos) {
+		// String after "pos" position.
+		str=(char*)(g_var_mem[var_num]+pos);
+	} else {
+		// String right "pos" characters.
+		// Determine length
+		str=(char*)g_var_mem[var_num];
+		for(i=0;str[i];i++);
+		if (0<=(i+pos)) {
+			str=(char*)(g_var_mem[var_num]+i+pos);
+		}
+	}
+	if (len<0) {
+		// Length is not specified.
+		// Return the string to the end.
+		return str;
+	}
+	// Length is specified.
+	// Construct temporary string containing specified number of characters.
+	ret=alloc_memory((len+1+3)/4,-1);
+	// Copy string.
+	for(i=0;(ret[i]=str[i])&&(i<len);i++);
+	ret[len]=0x00;
+	return ret;
+}
+
+void lib_clear(void){
+	int i;
+	// All variables will be integer 0
+	for(i=0;i<26;i++){
+		g_var_mem[i]=0;
+	}
+	// Clear memory allocation area
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_size[i]=0;
+	}
+	// Cancel PCG
+	stopPCG();
+	g_pcg_font=0;
+}
+
+void lib_let_str(char* str, int var_num){
+	int begin,end,size;
+	// Save pointer
+	g_var_mem[var_num]=(int)str;
+	// Determine size
+	for(size=0;str[size];size++);
+	// Check if str is in heap area.
+	begin=(int)str;
+	end=(int)(&str[size]);
+	if (begin<(int)(&g_heap_mem[0]) || (int)(&g_heap_mem[g_max_mem])<=end) {
+		// String is not within allcated block
+		return;
+	}
+	// Str is in heap area. Calculate values stored in heap data dimension
+	begin-=(int)(&g_heap_mem[0]);
+	begin>>=2;
+	end-=(int)(&g_heap_mem[0]);
+	end>>=2;
+	size=end-begin+1;
+	g_var_pointer[var_num]=begin;
+	g_var_size[var_num]=size;
+}
+
+int lib_rnd(){
+	int y;
+	y=g_rnd_seed;
+	y = y ^ (y << 13);
+	y = y ^ (y >> 17);
+	y = y ^ (y << 5);
+	g_rnd_seed=y;
+	return y&0x7fff;
+}
+
+char* lib_chr(int num){
+	char* str;
+	str=alloc_memory(1,-1);
+	str[0]=num&0x000000FF;
+	str[1]=0x00;
+	return str;
+}
+
+char* lib_dec(int num){
+	char* str;
+	int i,j,minus;
+	char b[12];
+	b[11]=0x00;
+	if (num<0) {
+		minus=1;
+		num=0-num;
+	} else {
+		minus=0;
+	}
+	for (i=10;0<i;i--) {
+		if (num==0 && i<10) break; 
+		b[i]='0'+rem10_32(num);
+		num=div10_32(num);
+	}
+	if (minus) {
+		b[i]='-';
+	} else {
+		i++;
+	}
+	str=alloc_memory(3,-1);
+	for(j=0;str[j]=b[i++];j++);
+	return str;
+}
+
+char* lib_hex(int num, int width){
+	char* str;
+	int i,j,minus;
+	char b[8];
+	str=alloc_memory(3,-1);
+	for(i=0;i<8;i++){
+		b[i]="0123456789ABCDEF"[(num>>(i<<2))&0x0F];
+	}
+	// Width must be between 0 and 8;
+	if (width<0||8<width) width=8;
+	if (width==0) {
+		// Width not asigned. Use minimum width.
+		for(i=7;0<i;i--){
+			if ('0'<b[i]) break;
+		}
+	} else {
+		// Constant width
+		i=width-1;
+	}
+	// Copy string to allocated block.
+	for(j=0;0<=i;i--){
+		str[j++]=b[i];
+	}
+	str[j]=0x00;
+	return str;
+}
+
+char* lib_connect_string(char* str1, char* str2){
+	int i,j;
+	char b;
+	char* result;
+	// Determine total length
+	for(i=0;str1[i];i++);
+	for(j=0;str2[j];j++);
+	// Allocate a block for new string
+	result=alloc_memory((i+j+1+3)/4,-1);
+	// Create connected strings 
+	for(i=0;b=str1[i];i++) result[i]=b;
+	for(j=0;b=str2[j];j++) result[i+j]=b;
+	result[i+j]=0x00;
+	free_temp_str(str1);
+	free_temp_str(str2);
+	return result;
+}
+
+void lib_string(int mode){
+	int i;
+	switch(mode){
+		case 0:
+			// CR
+			printchar('\n');
+			return;
+		case 1:
+			// ,
+			i=rem10_32((unsigned int)(cursor-TVRAM));
+			printstr("          "+i);
+			return;
+		default:
+			return;
+	}
+}
+
+void* lib_label(unsigned int label){
+	// This routine is used to jump to address dynamically determined
+	// in the code; for example: "GOTO 100+I"
+	unsigned int i,code,search;
+	void* ret;  
+	if (label&0xFFFF0000) {
+		// Label is not supported.
+		// Line number must bs less than 65536.
+		err_label_not_found();
+	} else {
+		// Line number
+		ret=search_label(label);
+		if (ret) return ret;
+		// Line number not found.
+		err_label_not_found();
+	}
+}
+
+int lib_keys(int mask){
+	int keys;
+	// Enable tact switches
+	if (inPS2MODE()) {
+		buttonmode();
+	}
+
+	keys=KEYPORT;
+	keys=
+		((keys&KEYUP)?    0:1)|
+		((keys&KEYDOWN)?  0:2)|
+		((keys&KEYLEFT)?  0:4)|
+		((keys&KEYRIGHT)? 0:8)|
+		((keys&KEYSTART)? 0:16)|
+		((keys&KEYFIRE)?  0:32);
+	return mask&keys;
+}
+
+int lib_val(char* str){
+	int i;
+	int val=0;
+	int sign=1;
+	char b;
+	// Skip blanc
+	for(i=0;0<=str[i] && str[i]<0x21;i++);
+	// Skip '+'
+	if (str[i]=='+') i++;
+	// Check '-'
+	if (str[i]=='-') {
+		sign=-1;
+		i++;
+	}
+	// Check '0x' or '$'
+	if (str[i]=='$' || str[i]=='0' && (str[i+1]=='x' || str[i+1]=='X')) {
+		// Hexadecimal
+		if (str[i++]=='0') i++;
+		while(1) {
+			b=str[i++];
+			if ('0'<=b && b<='9') {
+				val<<=4;
+				val+=b-'0';
+			} else if ('a'<=b && b<='f') {
+				val<<=4;
+				val+=b-'a'+10;
+			} else if ('A'<=b && b<='F') {
+				val<<=4;
+				val+=b-'A'+10;
+			} else {
+				break;
+			}
+		}
+	} else {
+		// Decimal
+		while(1) {
+			b=str[i++];
+			if ('0'<=b && b<='9') {
+				val*=10;
+				val+=b-'0';
+			} else {
+				break;
+			}
+		}
+	}
+	return val*sign;
+}
+
+char* lib_input(){
+	// Allocate memory for strings with 63 characters
+	char *str=calloc_memory((63+1)/4,-1);
+	// Enable PS/2 keyboard
+	if (!inPS2MODE()) {
+		ps2mode();
+		ps2init();
+	}
+	// Clear key buffer
+	do ps2readkey();
+	while(vkey!=0);
+	// Get string as a line
+	lineinput(str,63);
+	check_break();
+	return str;
+}
+
+unsigned char lib_inkey(int key){
+	int i;
+	// Enable PS/2 keyboard
+	if (!inPS2MODE()) {
+		ps2mode();
+		ps2init();
+	}
+	if (key) {
+		return ps2keystatus[key&0xff];
+	} else {
+		for(i=0;i<256;i++){
+			if (ps2keystatus[i]) return i;
+		}
+		return 0;
+	}
+}
+
+void lib_usepcg(int mode){
+	// Modes; 0: stop PCG, 1: use PCG, 2: reset PCG and use it
+	switch(mode){
+		case 0:
+			// Stop PCG
+			stopPCG();
+			break;
+		case 2:
+			// Reset PCG and use it
+			if (g_pcg_font) {
+				free_temp_str(g_pcg_font);
+				g_pcg_font=0;
+			}
+			// Continue to case 1:
+		case 1:
+		default:
+			// Use PCG
+			if (g_pcg_font) {
+				startPCG(g_pcg_font,0);
+			} else {
+				g_pcg_font=alloc_memory(256*8/4,ALLOC_PCG_BLOCK);
+				startPCG(g_pcg_font,1);
+			}
+			break;
+	}
+}
+
+void lib_pcg(unsigned int ascii,unsigned int fontdata1,unsigned int fontdata2){
+	unsigned int* pcg;
+	// If USEPCG has not yet executed, do now.
+	if (!g_pcg_font) lib_usepcg(1);
+	pcg=(unsigned int*)g_pcg_font;
+	// 0 <= ascii <= 0xff
+	ascii&=0xff;
+	// Update font data
+	ascii<<=1;
+	pcg[ascii]=(fontdata1>>24)|((fontdata1&0xff0000)>>8)|((fontdata1&0xff00)<<8)|(fontdata1<<24);
+	pcg[ascii+1]=(fontdata2>>24)|((fontdata2&0xff0000)>>8)|((fontdata2&0xff00)<<8)|(fontdata2<<24);
+}
+
+void lib_scroll(int x,int y){
+	int i,j;
+	int vector=y*WIDTH_X+x;
+	if (vector<0) {
+		// Copy data from upper address to lower address
+		for(i=0-vector;i<WIDTH_X*WIDTH_Y;i++){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X*WIDTH_Y+i+vector]=TVRAM[WIDTH_X*WIDTH_Y+i];
+		}
+	} else if (0<vector) {
+		// Copy data from lower address to upper address
+		for(i=WIDTH_X*WIDTH_Y-vector-1;0<=i;i--){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X*WIDTH_Y+i+vector]=TVRAM[WIDTH_X*WIDTH_Y+i];
+		}
+	} else {
+		return;
+	}
+	if (x<0) {
+		// Fill blanc at right
+		for(i=x;i<0;i++){
+			for(j=WIDTH_X+i;j<WIDTH_X*WIDTH_Y;j+=WIDTH_X){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	} else if (0<x) {
+		// Fill blanc at left
+		for(i=0;i<x;i++){
+			for(j=i;j<WIDTH_X*WIDTH_Y;j+=WIDTH_X){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	}
+	if (y<0) {
+		// Fill blanc at bottom
+		for(i=WIDTH_X*(WIDTH_Y+y);i<WIDTH_X*WIDTH_Y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X*WIDTH_Y+i]=cursorcolor;
+		}
+	} else if (0<y) {
+		// Fill blanc at top
+		for(i=0;i<WIDTH_X*y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X*WIDTH_Y+i]=cursorcolor;
+		}
+	}
+}
+
+void lib_wait(int period){
+	int i;
+	unsigned short dcount;
+	for(i=0;i<period;i++){
+		dcount=drawcount;
+		while(dcount==drawcount){
+			asm (WAIT);
+			check_break();
+		}
+	}
+}
+
+void allocate_graphic_area(){
+	if (!g_graphic_area) {
+		// Use this pointer like unsigned short GVRAM[G_H_WORD*G_Y_RES] __attribute__ ((aligned (4)));
+		g_graphic_area=(unsigned short*)alloc_memory(G_H_WORD*G_Y_RES/2,ALLOC_GRAPHIC_BLOCK);
+		// Start graphic and clear screen
+		init_graphic(g_graphic_area);
+		// Move current point to (0,0)
+		g_prev_x=g_prev_y=0;
+	}
+}
+
+void lib_usegraphic(int mode){
+	// Modes; 0: stop GRAPHIC, 1: use GRAPHIC, 2: reset GRAPHIC and use it
+	switch(mode){
+		case 0:
+			if (g_use_graphic){
+				// Stop GRAPHIC if used
+				set_graphmode(0);
+				g_use_graphic=0;
+				// Set timer4 for tempo
+				PR4=59473;       // 3632*262/16-1
+			} else {
+				// Prepare GRAPHIC area if not used and not allcated.
+				allocate_graphic_area();
+			}
+			break;
+		case 2:
+			// Reset GRAPHIC and use it
+			g_graphic_area=0;
+			// Continue to case 1:
+		case 1:
+		case 3:
+		default:
+			// Use GRAPHIC
+			allocate_graphic_area();
+			// Start showing GRAPHIC with mode 1, but not with mode 3
+			if (mode !=3 && !g_use_graphic){
+				set_graphmode(1);
+				g_use_graphic=1;
+				// Set timer4 for tempo
+				PR4=55756;       // ~=3405*262/16-1(55755.875)
+			}
+			break;
+	}
+}
+
+int lib_graphic(int a0, int a1, int v0){
+	unsigned char b;
+	enum functions func=(enum functions)(a0>>24);
+	int x1=(a0>>12)&0x0FFF;
+	int y1=a0&0x0FFF;
+	int x2=(a1>>12)&0x0FFF;
+	int y2=a1&0x0FFF;
+	// Disable if graphic area is not defined.
+	if (!g_graphic_area) return;
+	// Support 12 bit signed integer.
+	if (x1&0x0800) x1|=0x0FFFFF000;
+	if (y1&0x0800) y1|=0x0FFFFF000;
+	if (x2&0x0800) x2|=0x0FFFFF000;
+	if (y2&0x0800) y2|=0x0FFFFF000;
+	// If C is omitted in parameters, use current color.
+	if (v0==-1) {
+		v0=g_gcolor;
+	}
+	// If X1 or Y1 is -2048 (0xFFFFF800/0x0800), use the previous values.
+	if (x1==-2048) x1=g_prev_x;
+	if (y1==-2048) y1=g_prev_y;
+	switch(func){
+		case FUNC_POINT:// X1,Y1
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_PSET:// X1,Y1[,C]
+			g_pset(x1,y1,v0&0x0F);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_LINE:// X1,Y1,X2,Y2[,C]
+			if (y1==y2) g_hline(x1,x2,y1,v0&0x0F);
+			else g_gline(x1,y1,x2,y2,v0&0x0F);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_BOXFILL:// X1,Y1,X2,Y2[,C]
+			g_boxfill(x1,y1,x2,y2,v0&0x0F);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_CIRCLE:// X1,Y1,R[,C]
+			g_circle(x1,y1,x2,v0&0x0F);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_CIRCLEFILL:// X1,Y1,R[,C]
+			g_circlefill(x1,y1,x2,v0&0x0F);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_GPRINT:// X1,Y1,C,BC,S$
+			g_printstr(x1,y1,x2,y2,(unsigned char*)v0);
+			// Move current X,Y according to the string
+			while(b=((unsigned char*)v0)[0]){
+				v0++;
+				if (b==0x0d) {
+					x1=0;
+					y1+=8;
+				} else {
+					x1+=8;
+				}
+			}
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_PUTBMP2:// X1,Y1,M,N,BMP(label)
+			// Search CDATA
+			// It starts from either 0x00000020,0x00000021,0x00000022, or 0x00000023.
+			while((((unsigned int*)v0)[0]&0xfffffffc)!=0x00000020) v0+=4;
+			// CDATA starts from next word.
+			// MLB 3 bytes show skip byte(s).
+			v0+=4+(((unsigned int*)v0)[0]&0x03);
+			// Contunue to FUNC_PUTBMP.
+		case FUNC_PUTBMP:// X1,Y1,M,N,BMP(pointer)
+			g_putbmpmn(x1,y1,x2,y2,(const unsigned char*)v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_GCOLOR:// (X1,Y1)
+			v0=g_color(x1,y1);
+			break;
+		default:
+			break;
+	}
+	return v0;
+}
+
+void lib_var_push(int* sp,unsigned int flags){
+	unsigned int strflags=0;
+	int varnum;
+	int stack=0;
+	// Store flags in stack
+	// Note that sp[1] is used for string return address
+	sp[2]=flags;
+	for(varnum=0;varnum<26;varnum++){
+		if (flags&1) {
+			sp[(stack++)+4]=g_var_mem[varnum];
+			if (g_var_size[varnum] && g_var_mem[varnum]==(int)(&g_var_pointer[varnum])) {
+				// strflags change using varnum
+				strflags|=1<<varnum;
+				// Copy to VAR_BLOCK
+				move_to_perm_block(varnum);
+			}
+			// Clear variable
+			g_var_mem[varnum]=0;
+		}
+		flags>>=1;
+	}
+	sp[3]=strflags;
+}
+void lib_var_pop(int* sp){
+	// Note that sp is 4 bytes larger than that in lib_var_push
+	unsigned int flags;
+	unsigned int strflags;
+	int varnum;
+	int stack=0;
+	flags=sp[1];
+	strflags=sp[2];
+	for(varnum=0;varnum<26;varnum++){
+		if (flags&1) {
+			g_var_mem[varnum]=sp[(stack++)+3];
+			if (strflags&1) {
+				// Restore from VAR_BLOCK
+				move_from_perm_block(varnum);
+			}
+		}
+		flags>>=1;
+		strflags>>=1;
+	}
+}
+
+int lib_system(int a0,int v0){
+	switch(a0){
+		// Version info
+		case 0: return (int)SYSVER1;
+		case 1: return (int)SYSVER2;
+		case 2: return (int)BASVER;
+		case 3: return (int)FILENAME_FLASH_ADDRESS;
+		// Display info
+		case 20: return WIDTH_X;
+		case 21: return WIDTH_Y;
+		case 22: return G_X_RES;
+		case 23: return G_Y_RES;
+		case 24: return cursorcolor;
+		case 25: return g_gcolor;
+		case 26: return ((int)(cursor-TVRAM))%WIDTH_X;
+		case 27: return ((int)(cursor-TVRAM))/WIDTH_X;
+		case 28: return g_prev_x;
+		case 29: return g_prev_y;
+		// Keyboard info
+		case 40: return (int)inPS2MODE();
+		case 41: return (int)vkey;
+		case 42: return (int)lockkey;
+		case 43: return (int)keytype;
+		// Pointers to gloval variables
+		case 100: return (int)&g_var_mem[0];
+		case 101: return (int)&g_rnd_seed;
+		case 102: return (int)&TVRAM[0];
+		case 103: return (int)&FontData[0];
+		case 104: return (int)g_var_mem[ALLOC_PCG_BLOCK];
+		case 105: return (int)g_var_mem[ALLOC_GRAPHIC_BLOCK];
+		// Change system settings
+		case 200:
+			// ON/OFF monitor
+			if (v0) {
+				start_composite();
+			} else {
+				stop_composite();
+			}
+			break;
+		default:
+			break;
+	}
+	return 0;
+}
+
+char* lib_sprintf(char* format, int data){
+	char* str;
+	int i;
+	char temp[4];
+	if (!format) format="%g";
+	i=snprintf((char*)(&temp[0]),4,format,data)+1;
+	str=alloc_memory((i+3)/4,-1);
+	snprintf(str,i,format,data);
+	return str;
+}
+
+int lib_floatfuncs(int ia0,int iv0,enum functions a1){
+	volatile float a0,v0;
+	((int*)(&a0))[0]=ia0;
+	((int*)(&v0))[0]=iv0;
+	switch(a1){
+		case FUNC_FLOAT:
+			v0=(float)iv0;
+			break;
+		case FUNC_INT:
+			return (int)v0;
+		case FUNC_VALSHARP:
+			v0=strtof((const char*)iv0,0);
+			break;
+		case FUNC_SIN:
+			v0=sinf(v0);
+			break;
+		case FUNC_COS:
+			v0=cosf(v0);
+			break;
+		case FUNC_TAN:
+			v0=tanf(v0);
+			break;
+		case FUNC_ASIN:
+			v0=asinf(v0);
+			break;
+		case FUNC_ACOS:
+			v0=acosf(v0);
+			break;
+		case FUNC_ATAN:
+			v0=atanf(v0);
+			break;
+		case FUNC_SINH:
+			v0=sinhf(v0);
+			break;
+		case FUNC_COSH:
+			v0=coshf(v0);
+			break;
+		case FUNC_TANH:
+			v0=tanhf(v0);
+			break;
+		case FUNC_EXP:
+			v0=expf(v0);
+			break;
+		case FUNC_LOG:
+			v0=logf(v0);
+			break;
+		case FUNC_LOG10:
+			v0=log10f(v0);
+			break;
+		case FUNC_POW:
+			v0=powf(v0,a0);
+			break;
+		case FUNC_SQRT:
+			v0=sqrtf(v0);
+			break;
+		case FUNC_CEIL:
+			v0=ceilf(v0);
+			break;
+		case FUNC_FLOOR:
+			v0=floorf(v0);
+			break;
+		case FUNC_FABS:
+			v0=fabsf(v0);
+			break;
+		case FUNC_MODF:
+			v0=modff(v0,(void*)&a0);
+			break;
+		case FUNC_FMOD:
+			v0=fmodf(v0,a0);
+			break;
+		default:
+			err_unknown();
+			break;
+	}
+	return ((int*)(&v0))[0];
+};
+
+int* lib_dim(int varnum, int argsnum, int* sp){
+	int i,j;
+	static int* heap;
+	// Calculate total length.
+	int len=0;  // Total length
+	int size=1; // Size of current block
+	for(i=1;i<=argsnum;i++){
+		size*=sp[i]+1;
+		len+=size;
+	}
+	// Allocate memory
+	heap=calloc_memory(len,varnum);
+	// Construct pointers
+	len=0;
+	size=1;
+	for(i=1;i<argsnum;i++){
+		size*=sp[i]+1;
+		for(j=0;j<size;j++){
+			heap[len+j]=(int)&heap[len+size+(sp[i+1]+1)*j];
+		}
+		len+=size;
+	}
+	return heap;
+};
+
+int _call_library(int a0,int a1,int a2,enum libs a3);
+
+void call_library(void){
+	// Store s6 in g_s6
+	asm volatile("la $a2,%0"::"i"(&g_s6));
+	asm volatile("sw $s6,0($a2)");
+	// Copy $v0 to $a2 as 3rd argument of function
+	asm volatile("addu $a2,$v0,$zero");
+	asm volatile("j _call_library");
+}
+
+int _call_library(int a0,int a1,int v0,enum libs a3){
+	// usage: call_lib_code(LIB_XXXX);
+	// Above code takes 2 words.
+	check_break();
+	switch(a3){
+		case LIB_FLOAT:
+			return lib_float(a0,v0,(enum operator)a1); // see operator.c
+		case LIB_FLOATFUNCS:
+			return lib_floatfuncs(a0,v0,(enum functions)a1);
+		case LIB_STRNCMP:
+			return strncmp((char*)a0,(char*)a1,v0);
+		case LIB_MIDSTR:
+			return (int)lib_midstr(a1,v0,a0);
+		case LIB_RND:
+			return (int)lib_rnd();
+		case LIB_DEC:
+			return (int)lib_dec(v0);
+		case LIB_HEX:
+			return (int)lib_hex(v0,a0);
+		case LIB_CHR:
+			return (int)lib_chr(v0);
+		case LIB_VAL:
+			return lib_val((char*)v0);
+		case LIB_LETSTR:
+			lib_let_str((char*)v0,a0);
+			return;
+		case LIB_CONNECT_STRING:
+			return (int)lib_connect_string((char*)a0, (char*)v0);
+		case LIB_STRING:
+			lib_string(a0);
+			return v0;
+		case LIB_PRINTSTR:
+			printstr((char*)v0);
+			return v0;
+		case LIB_GRAPHIC:
+			return lib_graphic(a0,a1,v0);
+		case LIB_SPRINTF:
+			return (int)lib_sprintf((char*)v0,a0);
+		case LIB_VAR_PUSH:
+			lib_var_push((int*)a1,a0);
+			return v0;
+		case LIB_VAR_POP:
+			lib_var_pop((int*)a1);
+			return v0;
+		case LIB_SCROLL:
+			lib_scroll(a0,v0);
+			return v0;
+		case LIB_KEYS:
+			return lib_keys(v0);
+		case LIB_INKEY:
+			return (int)lib_inkey(v0);
+		case LIB_CURSOR:
+			setcursor(a0,v0,cursorcolor);
+			return v0;
+		case LIB_SOUND:
+			set_sound((unsigned long*)v0);
+			return v0;
+		case LIB_MUSICFUNC:
+			return musicRemaining();
+		case LIB_MUSIC:
+			set_music((char*)v0);
+			return v0;
+		case LIB_SETDRAWCOUNT:
+			drawcount=(v0&0x0000FFFF);
+			return v0;
+		case LIB_DRAWCOUNT:
+			return drawcount;
+		case LIB_SYSTEM:
+			return lib_system(a0,v0);
+		case LIB_RESTORE:
+			return lib_read(0,v0);
+		case LIB_RESTORE2:
+			return lib_read(1,v0);
+		case LIB_READ:
+			return lib_read(0,0);
+		case LIB_CREAD:
+			return lib_read(1,0);
+		case LIB_LABEL:
+			return (int)lib_label(v0);
+		case LIB_INPUT:
+			return (int)lib_input();
+		case LIB_USEGRAPHIC:
+			lib_usegraphic(v0);
+			return v0;
+		case LIB_USEPCG:
+			lib_usepcg(v0);
+			return v0;
+		case LIB_PCG:
+			lib_pcg(a0,a1,v0);
+			return v0;
+		case LIB_BGCOLOR: // BGCOLOR R,G,B
+			set_bgcolor(v0,a0,a1); //set_bgcolor(b,r,g);
+			return v0;
+		case LIB_PALETTE: // PALETTE N,R,G,B
+			set_palette(a0,v0,(a1>>16)&255,a1&255); // set_palette(n,b,r,g);
+			return v0;
+		case LIB_GPALETTE:// GPALETTE N,R,G,B
+			if (g_graphic_area) g_set_palette(a0,v0,(a1>>16)&255,a1&255); // g_set_palette(n,b,r,g);
+			return v0;
+		case LIB_CLS:
+			clearscreen();
+			return v0;
+		case LIB_GCLS:
+			if (g_graphic_area) g_clearscreen();
+			g_prev_x=g_prev_y=0;
+			return v0;
+		case LIB_COLOR:
+			setcursorcolor(v0);
+			return v0;
+		case LIB_GCOLOR:
+			g_gcolor=v0;
+			return v0;
+		case LIB_WAIT:
+			lib_wait(v0);
+			return v0;
+		case LIB_CLEAR:
+			lib_clear();
+			return v0;
+		case LIB_DIM:
+			return (int)lib_dim(a0,a1,(int*)v0);
+#ifdef __DEBUG
+		case LIB_DEBUG:
+			asm volatile("nop");
+			return v0;
+#endif
+		case LIB_DIV0:
+			err_div_zero();
+			return v0;
+		default:
+			err_unknown();
+			return v0;
+	}
+}
\ No newline at end of file

--- mips/tags/zoea1.00/music.c	(nonexistent)
+++ mips/tags/zoea1.00/music.c	(revision 148)
@@ -0,0 +1,483 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include <xc.h>
+#include "compiler.h"
+#include "api.h"
+
+/*
+	Timer3: 1/32 prescaler, toggle mode : 894886.25 Hz
+	PR3=2047 <-> 437 Hz
+	Timer4: 1/32 prescaler: 1789772.5 Hz
+	Timer4 29737 counts: 262 NTSC lines.
+*/
+
+/*
+	c:  1722
+	B:  1825
+	A#: 1933
+	A:  2048
+	G#: 2170
+	G:  2299
+	F#: 2435
+	F:  2580
+	E:  2734
+	D#: 2896
+	D:  3067
+	C#: 3251
+	C:  3444
+	Cb:	3650
+*/
+
+const static int g_keys[]={
+	1933,1722,3251,2896,2580,2435,2170,//  0 7# C# A#m
+	1933,1825,3251,2896,2580,2435,2170,//  7 6# F# D#m
+	1933,1825,3251,2896,2734,2435,2170,// 14 5# B  G#m
+	2048,1825,3251,2896,2734,2435,2170,// 21 4# E  C#m
+	2048,1825,3251,3067,2734,2435,2170,// 28 3# A  F#m
+	2048,1825,3251,3067,2734,2435,2299,// 35 2# D  Bm
+	2048,1825,3444,3067,2734,2435,2299,// 42 1# G  Em
+	2048,1825,3444,3067,2734,2580,2299,// 49 0  C  Am
+	2048,1933,3444,3067,2734,2580,2299,// 56 1b F  Dm
+	2048,1933,3444,3067,2896,2580,2299,// 63 2b Bb Gm
+	2170,1933,3444,3067,2896,2580,2299,// 70 3b Eb Cm
+	2170,1933,3444,3251,2896,2580,2299,// 77 4b Ab Fm
+	2170,1933,3444,3251,2896,2580,2435,// 84 5b Db Bbm
+	2170,1933,3650,3251,2896,2580,2435,// 91 6b Gb Ebm
+	2170,1933,3650,3251,2896,2734,2435 // 98 7b Cb Abm
+};
+
+/*
+	2^(1/12)    ~= 69433/(2^16)
+	1/(2^(1/12) ~= 1933/(2^11)
+*/
+
+#define toneFlat(x) ((((unsigned long)x)*69433)>>16)
+#define toneSharp(x) ((((unsigned long)x)*1933)>>11)
+
+/* local global vars */
+static int* g_tones;
+static int g_qvalue;
+static int g_lvalue;
+static int g_mpoint;
+static char* g_mstr;
+static int g_mspos;
+static unsigned short g_music[32];
+static unsigned short g_sound[32];
+static unsigned short g_musiclen[32];
+static unsigned char g_soundlen[32];
+static int g_musicstart;
+static int g_musicend;
+static int g_musicwait;
+static int g_soundstart;
+static int g_soundend;
+static int g_soundwait;
+static int g_soundrepeat;
+
+int musicRemaining(){
+	return (g_musicend-g_musicstart)&31;
+}
+
+#pragma interrupt timer4int IPL3SOFT vector 16
+void timer4int(){
+	unsigned int i;
+	// This function is called every 1/60 sec.
+	IFS0CLR=_IFS0_T4IF_MASK; //IFS0bits.T4IF=0;
+	if (g_soundstart!=g_soundend){
+		// Start timer & OC4
+		i=g_sound[g_soundstart];
+		if (i<0xffff) {
+			T3CONSET=0x8000;
+			PR3=i;
+			if (i<TMR3) TMR3=0;
+		} else {
+			T3CONCLR=0x8000;
+		}
+		if ((--g_soundwait)<=0) {
+			g_soundstart++;
+			if (g_soundstart==g_soundend || 31<g_soundstart) {
+				g_soundstart=0;
+				g_soundrepeat--;
+				if (0<g_soundrepeat) {
+					g_soundwait=g_soundlen[g_soundstart];
+				} else {
+					g_soundend=g_soundrepeat=g_soundwait=0;
+				}
+			} else {
+				g_soundwait=g_soundlen[g_soundstart];
+			}
+		}
+		// Shift music data even though without output.
+		if (g_musicstart!=g_musicend) {
+			if ((--g_musicwait)<=0) {
+				g_musicstart++;
+				g_musicstart&=31;
+				g_musicwait=g_musiclen[g_musicstart];
+			}
+		}
+	} else if (g_musicstart!=g_musicend) {
+		// Start timer & OC4
+		i=g_music[g_musicstart];
+		if (i<0xffff) {
+			T3CONSET=0x8000;
+			PR3=i;
+			if (i<TMR3) TMR3=0;
+		} else {
+			T3CONCLR=0x8000;
+		}
+		if ((--g_musicwait)<=0) {
+			g_musicstart++;
+			g_musicstart&=31;
+			g_musicwait=g_musiclen[g_musicstart];
+		}
+	} else {
+		// Stop timer
+		T3CONCLR=0x8000;
+	}
+}
+
+int musicGetNum(){
+	int i, ret;
+	char b;
+	// Skip non number character
+	for(i=0;(b=g_mstr[g_mspos+i])<'0' && '9'<g_mstr[g_mspos+i];i++);
+	// Determine the number
+	ret=0;
+	while('0'<=b && b<='9'){
+		ret*=10;
+		ret+=b-'0';
+		i++;
+		b=g_mstr[g_mspos+i];
+	}
+	g_mspos+=i;
+	return ret;
+}
+
+void init_music(){
+	// Use Timer3 and OC4 for sound.
+	RPB13R=5;        //Use RPB13 for OC4
+	OC4R=0;
+	OC4CON=0x000b;   // Timer3, toggle mode
+	OC4CONSET=0x8000;// Start OC4
+	T3CON=0x0050;    // Prescaller: 1:32 (1.8 MHz), not yet started
+
+	// Timer4 is used to intterupt every 1/60 sec, just after NTSC view.
+	T4CON=0x0040;    // Prescaller: 1:16
+	PR4=59473;       // 3632*262/16-1
+	// Timer 4 interruption, IPL3
+	IPC4bits.T4IP=3;
+	IPC4bits.T4IS=0;
+	IFS0bits.T4IF=0;
+	IEC0bits.T4IE=1;
+	// Wait until end of NTSC view.
+	while(!drawing);
+	while(drawing);
+	T4CONSET=0x8000; // Start timer 4.
+	
+	// Initializations for music/sound.
+	g_qvalue=160; // Q: 1/4=90
+	g_lvalue=20;   // L: 1/8
+	g_tones=(int*)&(g_keys[49]); // C major
+	g_musicstart=g_musicend=g_musicwait=g_soundstart=g_soundend=g_soundwait=g_soundrepeat=0;
+}
+
+void musicSetL(){
+	// Set length of a character.
+	// Syntax: L:n/m, where n and m are numbers.
+	int n,m;
+	n=musicGetNum();
+	g_mspos++;
+	m=musicGetNum();
+	g_lvalue=g_qvalue*n/m;
+}
+
+void musicSetQ(){
+	int i;
+	// Syntax: Q:1/4=n, where n is number.
+	// Skip "1/4="
+	for(i=0;g_mstr[g_mspos+i]!='=';i++);
+	g_mspos+=i+1;
+	i=musicGetNum();
+	if      (i<48)  { g_qvalue=320; /* 1/4=45  */ }
+	else if (i<53)  { g_qvalue=288; /* 1/4=50  */ }
+	else if (i<60)  { g_qvalue=256; /* 1/4=56  */ }
+	else if (i<70)  { g_qvalue=224; /* 1/4=64  */ }
+	else if (i<83)  { g_qvalue=192; /* 1/4=75  */ }
+	else if (i<102) { g_qvalue=160; /* 1/4=90  */ }
+	else if (i<132) { g_qvalue=128; /* 1/4=113 */ }
+	else if (i<188) { g_qvalue=96;  /* 1/4=150 */ }
+	else            { g_qvalue=64;  /* 1/4=225 */ }
+	g_lvalue=g_qvalue>>3;
+}
+
+void musicSetK(){
+	// Syntax: K:xxx
+	if (!strncmp((char*)&(g_mstr[g_mspos]),"A#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[0]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"D#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[7]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"G#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[14]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"C#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[21]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"F#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[28]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Bbm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[84]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Ebm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[91]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Abm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[98]);
+			return;
+	}
+	if (!strncmp((char*)&(g_mstr[g_mspos]),"C#",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[0]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"F#",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[7]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Bm",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[35]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Em",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[42]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Am",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[49]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Dm",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[56]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Gm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Bb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[63]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Cm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Eb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[70]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Fm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Ab",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[77]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Db",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[84]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Gb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[91]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Cb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[98]);
+			return;
+	}
+	switch(g_mstr[g_mspos]){
+		case 'B':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[14]);
+			return;
+		case 'E':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[21]);
+			return;
+		case 'A':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[28]);
+			return;
+		case 'D':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[35]);
+			return;
+		case 'G':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[42]);
+			return;
+		case 'C':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[49]);
+			return;
+		case 'F':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[56]);
+			return;
+		default:
+			err_music(g_mstr);
+			break;
+	}
+}
+void musicSetM(){
+	// Currently do nothing
+	musicGetNum();
+	musicGetNum();
+}
+
+void set_sound(unsigned long* data){
+	int sound;
+	int len;
+	int pos;
+	int datalen;
+	IEC0bits.T4IE=0; // Stop interruption, first.
+	// Initialize
+	g_soundrepeat=g_soundstart=g_soundend=0;
+	pos=0;
+	do {
+		while(data[1]!=0x00000020) data++; // Seek DATA statement
+		datalen=(data[0]&0x00007FFF)-1;    // Use bgezal statement containing data length.
+		data+=2;
+		while(0<datalen){
+			datalen--;
+			len=data[0]>>16;
+			sound=data[0]&0x0000FFFF;
+			data++;
+			if (len) {
+				// Shift tone if graphic is used
+				if (g_use_graphic) {
+					// MUL_15 instead of MUL_16 for CPU clock.
+					// sound=sound*15/16
+					sound-=(sound+7)>>4;
+				}
+				g_sound[pos]=sound-1;
+				g_soundlen[pos]=len;
+				pos++;
+				if (32<pos) {
+					err_music("Sound data too long.");
+					return;
+				}
+			} else {
+				g_soundrepeat=sound;
+				break;
+			}
+		}
+	} while(len);
+	g_soundend=pos;
+	g_soundwait=g_soundlen[0];
+	IEC0bits.T4IE=1; // Restart interrupt.
+}
+
+void set_music(char* str){
+	char b;
+	unsigned long tone,tonenatural;
+	int len;
+	g_mstr=str;
+	g_mspos=0;
+	while(0<(b=g_mstr[g_mspos])){
+		if (g_mstr[g_mspos+1]==':') {
+			// Set property
+			g_mspos+=2;
+			switch(b){
+				case 'L':
+					musicSetL();
+					break;
+				case 'Q':
+					musicSetQ();
+					break;
+				case 'K':
+					musicSetK();
+					break;
+				case 'M':
+					musicSetM();
+					break;
+				default:
+					err_music(str);
+					break;
+			}	
+		} else if ('A'<=b && b<='G' || 'a'<=b && b<='g' || b=='z') {
+			g_mspos++;
+			if (b=='z') {
+				tone=0;
+			} else if (b<='G') {
+				tone=g_tones[b-'A'];
+				tonenatural=g_keys[b-'A'+49];
+			} else {
+				tone=g_tones[b-'a']>>1;
+				tonenatural=g_keys[b-'a'+49]>>1;
+			}
+			// Check "'"s
+			while(g_mstr[g_mspos]=='\''){
+				g_mspos++;
+				tone>>=1;
+			}
+			// Check ","s
+			while(g_mstr[g_mspos]==','){
+				g_mspos++;
+				tone<<=1;
+				tonenatural<<=1;
+			}
+			// Check "^","=","_"
+			switch(g_mstr[g_mspos]){
+				case '^':
+					g_mspos++;
+					tone=toneSharp(tone);
+					break;
+				case '_':
+					g_mspos++;
+					tone=toneFlat(tone);
+					break;
+				case '=':
+					g_mspos++;
+					tone=tonenatural;
+					break;
+				default:
+					break;
+			}
+			// Check number for length
+			b=g_mstr[g_mspos];
+			if ('0'<=b && b<='9') {
+				len=g_lvalue*musicGetNum();
+			} else {
+				len=g_lvalue;
+			}
+			if (g_mstr[g_mspos]=='/') {
+				g_mspos++;
+				len=len/musicGetNum();
+			}
+			// Shift tone if graphic is used
+			if (g_use_graphic) {
+				// MUL_15 instead of MUL_16 for CPU clock.
+				// tone=tone*15/16
+				tone-=(tone+7)>>4;
+			}
+			// Update music value array
+			IEC0bits.T4IE=0; // Stop interruption, first.
+			if (g_musicstart==g_musicend) {
+				g_musicwait=len;
+			}
+			g_music[g_musicend]=(tone-1)&0x0000FFFF;
+			g_musiclen[g_musicend]=len;
+			g_musicend++;
+			g_musicend&=31;
+			IEC0bits.T4IE=1; // Restart interruption.
+		} else {
+			err_music(str);
+		}
+		// Go to next character
+		while(0<g_mstr[g_mspos] && g_mstr[g_mspos]<=0x20 || g_mstr[g_mspos]=='|') g_mspos++;
+	}
+}
\ No newline at end of file

--- mips/tags/zoea1.00/help.txt	(nonexistent)
+++ mips/tags/zoea1.00/help.txt	(revision 148)
@@ -0,0 +1,585 @@
+＜BASIC言語の書式＞
+BASICプログラムの記述は、行番号式、ラベル式、その混合、いずれの方法でも構
+いません。以下、仕様について述べます。
+
+＜利用可能な変数型＞
+利用できる変数の型は、32ビット符号付整数(-2147483648 以上 [phone] 以
+下)と、文字列型の２種類です。文字列の末端部には0x00が付加されます。
+
+A-Zの２６個の整数型変数が利用可能です。文字列として扱う場合はA$のように記
+述します。ただし、A（整数型）とA$（文字列型）を同時に使用することは出来ま
+せん。
+
+整数型の定数は、１０進法で記述します。１６進法を使う場合、「$1200」のよう
+に、頭に「$」を付加するか、「0x1200」の様に表記して下さい。
+
+文字列型の定数は、「"」で囲って記述してください。「"」を使用する場合は、
+「CHR$($22)」のように記述することが出来ます。
+
+＜命令＞
+以下、x, y, z等は整数値を、x$, y$, z$は文字列を、x#, y#, z#は浮動
+小数点型実数値を指します。xxx, yyy, zzz, www等は任意のステートメントを
+指します。[ ]は省略可能である事を示します。
+
+命令同士を「:」で区切ることにより、一行で複数のコマンドを処理すること
+が出来ます。
+
+BGCOLOR r,g,b
+	背景色指定。
+BREAK
+	FOR-NEXT, DO-LOOP, WHILE-WENDループから抜け出す。
+CDATA x[,y[,z[...]]]
+	データー列を8ビット整数値で指定する。
+CLEAR
+	すべての文字列型変数と整数型配列を破棄し、整数値を０とする。また、
+	PCGの使用をやめ、表示キャラクターをリセットする。
+CLS
+	スクリーン消去。
+COLOR x
+	テキスト色指定。
+CURSOR x,y
+	カーソル位置指定。
+CDATA xxx[,yyy[,zzz[...]]]
+	データー列を８ビット整数値で指定する。
+DATA xxx[,yyy[,zzz[...]]]
+	データー列を整数値もしくは文字列で指定する。
+DIM xxx [, yyy [, zzz [, ... ]]]
+	整数型もしくは浮動小数点型の配列を割り当てる。
+	xxx,yyy,zzzは、例えば「A(10)」のように記述する。この場合、A(0)から
+	A(10)までの１１個の整数型変数が確保される。浮動小数点型配列の場合は、
+	「A#(10)」の様に記述する。多次元配列も、宣言することが出来る。
+DO WHILE x
+LOOP
+	x が0以外の場合、DO文からLOOP文までのステートメントを繰り返し実行する。
+DO UNTIL x
+LOOP
+	x が0の場合、DO文からLOOP文までのステートメントを繰り返し実行する。
+DO
+LOOP WHILE x
+	DO文からLOOP文までのステートメントを実行し、x が0以外の場合、繰り返す。
+DO
+LOOP UNTIL x
+	DO文からLOOP文までのステートメントを実行し、x が0の場合、繰り返す。
+DRAWCOUNT
+	DRAWCOUNT値を指定する。DRAWCOUNT値に付いては、DRAWCOUNT()関数を
+	参照。
+END
+	BASICプログラムを停止する。
+EXEC x[,y[,z[...]]]
+	機械語を実行する。ただし、x,y,zは32ビット整数値。
+FOR x=yyy TO zzz [ STEP www ]
+NEXT
+	yyyで示された計算結果をxに代入し、xの値がzzzになるまで次のNEXT文
+	までのステートメントを、繰り返し実行する。繰り返しのたび、xの値は
+	wwwずつ増加する（省略された場合は１ずつ）。「NEXT」の次に何も記述
+	しないことに注意。
+GOSUB xxx [, yyy [, zzz [, ... ]]]
+	現在の実行位置を記憶し、xxx行目(もしくはラベル)に移動する。yyy, zzz
+	等は、サブルーチンに引き継がれる引数（ARGS()関数を参照）。
+GOTO xxx
+	xxx行目(もしくはラベル)に移動する。
+IF xまたはx# THEN yyy [ ELSE zzz ]
+	xが0以外のとき、yyyを、0のときzzzを実行。yyyおよびzzzは、複数のステート
+	メントを「:」で挟んで記述可能。
+IF xまたはx# THEN
+xxx
+[ELSEIF yまたはy# THEN
+yyy]
+[ELSE
+zzz]
+ENDIF
+	xが0以外の時xxxを、それ以外で且つyが0以外の時（記述された場合）yyyを、
+	それ以外の場合にzzzを実行。ELSEIFステートメントは、複数記述可。各行で、
+	THENステートメントの次には何も記入しないことに注意。
+LABEL xxx
+	GOTO/GOSUBのジャンプ先を登録する。xxxは、英数字６文字以内の文字列。
+[LET] x=yyy
+	yで示された計算結果を、x（整数型変数）に代入する。「LET」は省略可。
+[LET] x#=yyy
+	yで示された計算結果を、x（不動州数点方型変数）に代入する。「LET」は省略可。
+[LET] x$=yyy
+	yyyで示された文字列（もしくは連結結果;連結演算子は「+」）を、x$に
+	代入する。「LET」は省略可。
+MUSIC x$
+	BGMを演奏する。詳細は、下記<MUSIC>の項を参照。
+VAR xxx [, yyy [, zzz [, ... ]]]
+	サブルーチン内で使う、ローカル変数を指定する。xxx, yyy等は、A-Zの
+	アルファベットで指定する。
+WHILE x
+WEND
+	x が0以外の場合、WHILE文からWEND文までのステートメントを繰り返し実行する。
+PALETTE n,r,g,b
+	パレット指定。
+PCG x,y,z
+	ASCIIコードがxの文字の表示キャラクターを変更する。y,zは、キャラク
+	ターデーター。詳細は、下記<PCG>の項を参照。
+POKE x,y
+	xで示される物理的アドレスに、yで示される値(１バイト値)を書き込む。
+PRINT [ xまたはx$またはx# [ ,または; [ yまたはy$またはy# [ ... ]]]]
+	ディスプレイに、整数値または文字列を表示する。「;」を使用した場
+	合、次の表示が続けて行われる。「,」を使用した場合、１０文字ずつ
+	に区切って表示される。どちらも使用しない場合、次の表示は行を変え
+	て行われる。
+REM xxx
+	何も実行しない
+RESTORE xxx
+	DATA読み出し開始位置を指定。xxxは行番号もしくはラベル。
+RETURN
+	最後に実行されたGOSUB文の次のステートメントに移動する。戻り値を指
+	定することがができる。この場合の戻り値はGOSUB()関数にて取得が可能。
+SCROLL x,y
+	画面を横方向、もしくは縦方向(斜めも可)に動かす。動かす方向と大きさ
+	は、x, yでそれぞれ、横方向の移動度、縦方向の移動度として指定する。
+SOUND xxx
+	効果音を再生する。詳細は、下記<SOUND>の項を参照。xxxは行番号もしく
+	はラベル。
+SYSTEM x , y
+	様々なシステム値の設定を行なう。＜SYSTEM＞の項を参照。
+USEGRAPHIC [x]
+	グラフィックディスプレイを使用、もしくは使用停止する。x=0で使用停止、
+	x=1で使用、x=2で画面とパレットをクリアーして使用、x=3でグラフィック領
+	域を確保するが表示はキャラクターディスプレイのまま。ただし、グラフィッ
+	クディスプレイ未使用の状態でx=0の場合は、領域を確保する。xを省略した場
+	合は、x=1と同じ。
+USEPCG [x]
+	PCGを使用、もしくは使用停止する。x=0で使用停止、x=1で使用、x=2で
+	キャラクターをリセットして使用。xを省略した場合は、x=1と同じ。
+
+WAIT x
+	xで示された時間、プログラムの実行を停止する。xが60の場合、約１秒間
+	停止。
+
+＜グラフィック関連命令＞
+
+BOXFILL [x1,y1],x2,y2[,c]
+	座標(x1,y1),(x2,y2)を対角線とするカラーcで塗られた長方形を描画。
+CIRCLE [x,y],r[,c]
+	座標(x,y)を中心に、半径r、カラーcの円を描画。
+CIRCLEFILL [x,y],r[,c]
+	座標(x,y)を中心に、半径r、カラーcで塗られた円を描画。
+GCLS
+	画面クリアー。
+GCOLOR c
+	それぞれの命令で、cを省略した場合の色を指定。
+GPALETTE n,r,g,b
+	パレット指定。
+GPRINT [x,y],c,bc,s$
+	座標(x,y)にカラーcで文字列s$を表示、bc:背景色（負数の場合背景色指定なし）。
+LINE [x1,y1],x2,y2[,c]
+	座標(x1,y1)から(x2,y2)にカラーcで線分を描画。
+POINT x,y
+	グラフィック現在位置を、設定する。
+PSET [x,y][,c]
+	座標(x,y)の位置にカラーcで点を描画。
+PUTBMP [x,y],m,n,bbb
+	横m*縦nドットのキャラクター(bbbで指定)を座標(x,y)に表示。
+	サイズm*nの配列bmpに、単純にカラー番号を並べる。
+	ただし、カラーが0の部分は透明色として扱う。ただし、bbbはラベル名もし
+	くは配列へのポインター。
+
+＜整数型関数＞
+以下、x, y, zは整数値を、x$, y$, z$は文字列を指します。[ ]は省略可能である事
+を示します。
+
+ABS(x)
+	xの絶対値を返す。
+ARGS(x)
+	サブルーチン中で、GOSUBに渡されたx番目の引数を整数値として取り出す。
+ASC(x$)
+	文字列の最初の一文字の、アスキーコードを返す。
+CREAD()
+	DATA文の後から、一つずつデーター（8ビット整数値）を読み出す。「READ()」
+	関数も参照。
+DRAWCOUNT()
+	DRAWCOUNT値を得る。DRAWCOUNTは１６ビット整数値で、1/60秒ごとに１ずつ
+	増える。
+GCOLOR(x,y)
+	グラフィック座標(x,y)の表示中パレット番号を返す。
+GOSUB(xxx [, y [, z [, ... ]]])
+	GOSUB命令と同じだが、戻り値(RETURNを参照)を得ることが出来る。xxxは、
+	ラベルもしくは行番号。。yyy, zzz 等は、サブルーチンに引き継がれる引数（
+	ARGS()関数を参照）。
+INKEY([x])
+	xを指定しない場合、現在押されているキーのASCII値を返す。押されていな
+	い場合は、０。ASCII値でxを指定した場合、そのキーが押されているかどう
+	かを返す。
+INT(x#)
+	実数値x#を整数値に変換して返す。
+KEYS([x])
+	キー入力を得る。xの値は以下の通り。xを指定しない場合は、x=63と同じ。
+		KEYUP:    1
+		KEYDOWN:  2
+		KEYLEFT:  4
+		KEYRIGHT: 8
+		KEYSTART: 16
+		KEYFIRE:  32
+LEN(x$)
+	文字列の長さを返す。
+MUSIC()
+	BGMの演奏の残り数を返す。
+NOT(x)
+	x=0の場合に１を、そうでない場合に０を返す。
+PEEK(x)
+	xで示される物理アドレスから１バイト読み取り、返す。
+READ()
+	DATA文の後から、一つずつデーター（32ビット整数値）を読み出す。「CREAD()」
+	関数も参照。
+RND()
+	0から32767までの擬似乱数を返す。
+SGN(x)
+	xの符号(-1, 0, または1)を返す。
+STRNCMP(x$,y$,z)
+	２つの文字列のうちz文字分を比較し、結果を返す。同じ文字列の場合は０。
+SYSTEM(x)
+	様々なシステム値を、整数値で返す。「＜システム変数＞」の項を参照。
+TVRAM([x])
+	ビデオRAMのx番目の内容を、バイト値で返す。xを省略した場合、ビデオ
+	RAMの開始位置の物理アドレスを返す。
+VAL(x$)
+	１０進数もしくは１６進数文字列としてのx$の値を、整数値で返す。
+
+＜浮動小数点型関数＞
+ACOS#(x#)
+	x# の逆余弦を実数値で返す。
+ARGS#(x)
+	サブルーチン中で、GOSUBに渡されたx番目の引数を実数値として取り出す。
+ASIN#(x#)
+	x# の逆正弦を実数値で返す。
+ATAN#(x#)
+	x# の逆正接を実数値で返す。
+CEIL#(x#)
+	x# 以上の最小の整数を実数値で返す。
+COS#(x#)
+	x# の余弦を実数値で返す。
+COSH#(x#)
+	x# の双曲線余弦を実数値で返す。
+EXP#(x#)
+	eを底とする x# の指数関数値を実数値で返す。
+FABS#(x#)
+	x# の絶対値を実数値で返す。
+FLOAT#(x)
+	整数値 x を浮動小数点型実数値に変換して返す。
+FLOOR#(x#)
+	x# 以下の最大の整数を実数値で返す。
+FMOD#(x#,y#)
+	x# を y# で割った剰余を実数値で返す。
+GOSUB#(xxx [, y [, z [, ... ]]])
+	GOSUB命令と同じだが、戻り値(RETURNを参照)を得ることが出来る。xxxは、
+	ラベルもしくは行番号。。yyy, zzz 等は、サブルーチンに引き継がれる引数（
+	ARGS()関数を参照）。
+LOG#(x#)
+	x# の自然対数を実数値で返す。
+LOG10#(x#)
+	x# の常用対数を実数値で返す。
+MODF#(x#)
+	x# の小数部を実数値で返す。
+PI#
+	3.141593を返す。
+POW#(x#,y#)
+	x# の y# 乗を実数値で返す。
+SIN#(x#)
+	x# の正弦を実数値で返す。
+SINH#(x#)
+	x# の双曲線正弦を実数値で返す。
+SQRT#(x#)
+	x# の平方根を実数値で返す。
+TAN#(x#)
+	x# の正接を実数値で返す。
+TANH#(x#)
+	x# の双曲線正接を実数値で返す。
+VAL#(x$)
+	１０進数文字列としてのx$の値を、実数値で返す。
+
+＜文字列型関数＞
+A$(x [,y])など
+	xの値が０の場合、文字列全体を返す。
+	xの値が正の場合、xで示される位置より右側の文字列を返す。
+	xの値が負のとき、文字列の右側x文字を返す。
+	yが指定された場合、y文字分の文字列を返す。
+ARGS$(x)
+	サブルーチン中で、GOSUBに渡されたx番目の引数を文字列として取り出す。
+CHR$(x)
+	xをアスキーコードとする文字を返す。
+DEC$(x)
+	xの値を、１０進数の文字列として返す。
+FLOAT$(x#)
+	実数値x#を、１０進数の文字列として返す。
+GOSUB$(xxx [, y [, z [, ... ]]])
+	GOSUB命令と同じだが、戻り値(RETURNを参照)を文字列として得ることが出来る。
+	xxxは、ラベルもしくは行番号。。yyy, zzz 等は、サブルーチンに引き継がれる引数
+	（ARGS()関数を参照）。
+HEX$(x [,y])
+	xの値を、１６進数の文字列として返す。yが指定された場合、yバイト長の
+	文字列になる。
+INPUT$()
+	文字列入力状態になり、入力が終了すると(Enterが押されると)文字列を返す。
+SPRINTF$(x$,y#)
+	x$で示される書式に従って、実数y#の内容を文字列として返す。
+SYSTEM$(x)
+	様々なシステム値を、文字列で返す。「＜システム変数＞」の項を参照。
+READ$()
+	DATA文の後から、一つずつ文字列データーを読み出す。
+
+＜整数演算子＞
+-x
+	符号を反転
+x + y
+	整数加算
+x - y
+	整数減算
+x * y
+	整数乗算
+x / y
+	整数除算
+x % y
+	整数剰余
+x >> y
+	xの値をyビット右シフト
+x << y
+	xの値をyビット左シフト
+x = y
+	２つの整数値が等しい場合に１、そうでないときに０
+x != y
+	２つの整数値が等しい場合に０、そうでないときに１
+x < y
+	xがyより小さい場合に１、そうでないときに０
+x <= y
+	xがyより小さいか等しい場合に１、そうでないときに０
+x > y
+	xがyより多きい場合に１、そうでないときに０
+x >= y
+	xがyより多きいか等しい場合に１、そうでないときに０
+x AND y
+	xとyの値のビットごとの AND（論理積でないことに注意）
+x OR y
+	xとyの値のビットごとの OR
+x XOR y
+	xとyの値のビットごとの XOR
+
+なお、整数演算子の優先順位は、優先度が高いものから以下の順です。
+
++ - (単項演算子)
+* / %
++ - (加算・減算)
+<< >>
+< <= > >=
+= !=
+XOR
+AND
+OR
+
+＜文字列演算子＞
+x$ + y$
+	文字列の連結
+
+＜浮動小数点型演算子＞
+-x#
+	符号を反転
+x# + y#
+	実数加算
+x# - y#
+	実数減算
+x# * y#
+	実数乗算
+x# / y#
+	実数除算
+x# = y#
+	２つの実数値が等しい場合に１、そうでないときに０
+x# != y#
+	２つの実数値が等しい場合に０、そうでないときに１
+x# < y#
+	xがyより小さい場合に１、そうでないときに０
+x# <= y#
+	xがyより小さいか等しい場合に１、そうでないときに０
+x# > y#
+	xがyより多きい場合に１、そうでないときに０
+x# >= y#
+	xがyより多きいか等しい場合に１、そうでないときに０
+x# AND y#
+	xとyの値の論理積（ビットごとの AND でないことに注意）
+x# OR y#
+	xとyの値の論理和（ビットごとの OR でないことに注意）
+
+なお、実数演算子の優先順位は、優先度が高いものから以下の順です。
+
++ - (単項演算子)
+* /
++ - (加算・減算)
+< <= > >=
+= !=
+AND
+OR
+
+＜MUSIC＞
+MUSIC命令では、BGM用のデーターを文字列で指定します。文字列の書式は、ABC 
+notationに準拠しています。ただし、すべての記法が使えるわけではありません。
+なお、キーや速度などのデフォルト設定値は以下の通りです。
+
+Q: 1/4=90
+L: 1/8
+K: C
+
+BGM演奏時に一度に設定できる音の数は、31迄です。これを超えて音楽を再生したい
+場合は、MUSIC()関数の戻り値を調べ、その値が十分小さくなってから、次のMUSIC命
+令を実行するようにします。
+
+添付のmusic.basに、使い方に関するサンプルがありますので、参考にして下さい。
+
+＜SOUND＞
+SOUND命令では、DATA列のデーターを、行番号もしくはラベルで指定します。SOUND命
+令による効果音再生中は、BGMは再生されません。また、前の効果音が終わる前に次
+のSOUND命令を実行すると、前の効果音の再生は停止し、新しい効果音がすぐに再生
+されます。
+
+DATA列では、３２ビット整数値として、交換音を表現します。この整数値の下位１６
+ビットは周波数の指定です。2048が440Hz(ラの音)に対応します。値が大きくなるほ
+ど、より低い音が出ます。上位１６ビットは、音の長さです。1が、1/60秒に相当し
+ます。最後に、65535以下の値で、効果音の繰り返し回数を指定します。これらのデー
+ターの数は、32を超えないようにして下さい。
+
+添付のsound.basに、使い方に関するサンプルがありますので、参考にして下さい。
+
+＜PCG＞
+PCG(Programmable Character Generator)を用いると、ASCIIコードごとにフォント
+を指定して、疑似グラフィックスとして表示させることが出来ます。使用する場合
+は、まず
+
+USEPCG
+
+とします。フォントの変更は、PCGステートメントを用いて、
+
+PCG 0x80,0x80402010,0x08040201
+
+の様に設定します。この例では、ASCIIコード0x80の文字のフォントを設定してい
+て、バックスラッシュの様な記号(左上から右下に向かう斜め線)が表示されるよう
+になります。PCGの利用を停止し、オリジナルのフォントに戻す場合は、
+
+USEPCG 0
+
+とします。再度PCGを使用したい場合は、
+
+USEPCG
+
+として下さい。先に設定したフォントデーターが、復活します。なお、先に設定し
+たフォントデーターを破棄してPCGの使用を始めたい場合は、
+
+USEPCG 2
+
+として下さい。
+
+＜システム変数＞
+SYSTEM関数及びSYSTEMステートメントを用いて、各種システム情報をやりとりするこ
+とが出来ます。
+
+SYSTEM$(0)
+	MachiKania バージョン文字列、"Zoea"を返す。
+SYSTEM$(1)
+	MachiKania バージョン文字列、"1.0"等を返す。
+SYSTEM$(2)
+	BASIC バージョン文字列、"KM-1200"等を返す。
+SYSTEM$(3)
+	現在実行中のHEXファイル名、"ZOEA.HEX"等を返す。
+SYSTEM(20)
+	キャラクターディスプレイ横幅を返す。
+SYSTEM(21)
+	キャラクターディスプレイ縦幅を返す。
+SYSTEM(22)
+	グラフィックディスプレイ横幅を返す。
+SYSTEM(23)
+	グラフィックディスプレイ横幅を返す。
+SYSTEM(24)
+	キャラクターディスプレイ用の指定色を返す。
+SYSTEM(25)
+	グラフィックディスプレイ用の指定色を返す。
+SYSTEM(26)
+	キャラクターディスプレイの、現在のX位置を返す。
+SYSTEM(27)
+	キャラクターディスプレイの、現在のY位置を返す。
+SYSTEM(28)
+	グラフィックディスプレイの、現在のX位置を返す。
+SYSTEM(29)
+	グラフィックディスプレイの、現在のY位置を返す。
+SYSTEM(40)
+	PS/2キーボードを使用中かどうかを返す。
+SYSTEM(41)
+	PS/2キーボード情報、vkeyを返す。
+SYSTEM(42)
+	PS/2キーボード情報、lockkeyを返す。
+SYSTEM(43)
+	PS/2キーボード情報、keytypeを返す。
+SYSTEM(100)
+	変数格納領域(g_var_mem)へのポインターを返す。
+SYSTEM(101)
+	乱数シードへのポインターを返す。
+SYSTEM(102)
+	キャラクターディスプレイ領域(TVRAM)へのポインターを返す。
+SYSTEM(103)
+	フォント領域へのポインターを返す。
+SYSTEM(104)
+	PCGフォント領域へのポインターを返す。
+SYSTEM(105)
+	グラフィックディスプレイ領域へのポインターを返す。
+SYSTEM 200,x
+	ディスプレイの表示を停止(xが0のとき)、もしくは開始(xが0以外の時)する。
+
+＜ヒント＞
+FOR-NEXTループ、WHILE-WENDループ、DO-LOOPループの途中で、GOTO文でループの
+外に飛んだり、RETURN文を実行したりすると、予期せぬ結果（機器のリセット等）を
+引き起こします。ただし、GOSUB文でサブルーチンを呼んだり、別のループをネスト
+して使う事は可能です。
+
+ON GOTO分やON GOSUB文はサポートしていません。ただし、例えば次のように記述す
+ることで、同様の動作をさせることは可能です。
+ GOSUB 10000+A
+ ....
+ 10000 PRINT "A=0" : RETURN
+ 10001 PRINT "A=1" : RETURN
+ 10002 PRINT "A=2" : RETURN
+
+一行中で連続して文字列を扱うと、"String too complexed"というエラーがでて、
+停止することがあります。この場合は、文字列を扱う命令を独立した行するか、文
+字列関連の演算を幾つかのステップに分けて、それぞれ１行ずつの記述にして試し
+てみて下さい。
+
+＜バージョン履歴＞
+・KM-1200 2016年8月公開。
+　１．グラフィックディスプレイ機能および、関連のステートメント群を追加。
+　２．浮動小数点演算機能、及び、算術演算関数群を追加。
+　３．VAR, BREAK, SYSTEMステートメントを追加。
+　４．DO-LOOP, WHILE-WENDループ構造文を追加。
+　５．IF THEN - ELSEIF - ELSE - ENDIFによる、複数行での条件分岐表現を追加。
+　６．GOSUBステートメント及びGOSUB()関数に第二以降の引数を指定出来る様にし、
+　　　サブルーチン中でARGS()関数により取り出せるようにした。
+　７．８ビット整数型を扱うCDATAステートメントとCREAD()関数を追加。
+　８．DATAステートメントで文字列を扱える様にし、READ$()で読めるようにした。
+　９．多次元配列をサポート。
+　10．例外発生時に、情報を表示するようにした。
+　11．FOR-NEXTループに於いて、TO値に一致する時だけではなく、値を超えた場合
+　　　でもループを抜けるようにした。
+　12．MUSICステートメント用のスクリプトにエラーがある際、エラー発生行が正し
+　　　く表示されない不具合を修正。
+　13．ビットシフト演算子を、追加。
+
+・KM-1120 2016年2月公開。
+　１．PCG機能を追加。
+　２．SCROLL命令を追加。
+　３．WAIT命令を追加。
+　４．「Ctrl+Break」キーによる実行停止に対応。
+　５．FOR無しでNEXTを実行した場合、GOSUB無しでRETURNを実行した場合にエラー
+　　　を表示して停止するようにした。
+
+・Ver 1.1.0 (KM-1110) 2015年12月公開。
+　１．2015年11月21日に変更されたPIC32TVGSの仕様に対応。
+　２．PS/2キーボードに対応。
+　３．INKEY() INPUT$() VAL() DEC$() の４つの関数を追加。
+　４．TVRAM() ASC() PEEK()が、0x80-0xFFの値に関して負の数を返していた不具合
+　　　を修正。
+　５．DIMステートメントにより配列を定義した際、すべての要素がゼロになるよう
+　　　にした。
+　６．単項演算子、「-」「+」を追加。
+　７．LABEL定義されていない飛び先にGOTOするとリセットされる不具合を修正。
+　８．同一のLABELを複数回使用している場合に、コンパイルエラーが出るように修
+　　　正。
+　９．引数を持たないPRINT文に対応。
+
+・Ver 1.0.5 (KM-1100) 最初の正規公開バージョン。

--- mips/tags/zoea1.00/run.c	(nonexistent)
+++ mips/tags/zoea1.00/run.c	(revision 148)
@@ -0,0 +1,139 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+#include "editor.h"
+#include "main.h"
+
+char* printdec(int num){
+	char str[11];
+	int i;
+	if (num<0) {
+		printchar('-');
+		num=0-num;
+	}
+	for(i=10;0<i;i--){
+		if (num==0 && i<10) break;
+		str[i]='0'+rem10_32(num);
+		num=div10_32(num);
+	}
+	for(i++;i<11;i++) {
+		printchar(str[i]);
+	}
+}
+
+int runbasic(char *appname,int test){
+// BASICソースのコンパイルと実行
+// appname 実行するBASICソースファイル
+// test 0:コンパイルと実行、0以外:コンパイルのみで終了
+//
+// 戻り値
+//　　0:正常終了
+//　　-1:ファイルエラー
+//　　-2:リンクエラー
+//　　1以上:コンパイルエラーの発生行（行番号ではなくファイル上の何行目か）
+	int i;
+	char* buff;
+	char* err;
+
+	// Set grobal pointer
+	g_gp=get_gp();
+	// Set source positions
+	buff=(char*)&(RAM[RAMSIZE-512]);
+	g_source=(char*)(&buff[0]);
+	g_srcpos=0;
+	// Set object positions
+	g_object=(int*)(&RAM[0]);
+	g_objpos=0;
+	g_objmax=g_object+(RAMSIZE-512)/4; // Buffer area excluded.
+	// Initialize SD card file system
+	err=init_file(buff,appname);
+	if (err) {
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Can't Open ");
+		printstr(appname);
+		printchar('\n');
+		return -1;
+	}
+
+	// Initialize parameters
+	g_pcg_font=0;
+	g_use_graphic=0;
+	g_graphic_area=0;
+	clearscreen();
+	setcursor(0,0,7);	
+
+	printstr("BASIC "BASVER"\n");
+	wait60thsec(15);
+	// Initialize music
+	init_music();
+
+	printstr("Compiling...");
+
+	// Compile the file
+	err=compile_file();
+	close_file();
+	if (err) {
+		// Compile error
+		printstr(err);
+		printstr("\nAround: '");
+		for(i=0;i<5;i++){
+			printchar(g_source[g_srcpos-2+i]);
+		}
+		printstr("' in line ");
+		printdec(g_line);
+		printstr("\n");
+		for(i=g_srcpos;0x20<=g_source[i];i++);
+		g_source[i]=0x00;
+		for(i=g_srcpos;0x20<=g_source[i];i--);
+		printstr(g_source+i);
+		return g_fileline;
+	}
+
+	// Link
+	err=link();
+	if (err) {
+		// Link error
+		printstr(err);
+		printstr(resolve_label(g_label));
+		return -2;
+	}
+
+	// All done
+	printstr("done\n");
+	if(test) return 0; //コンパイルのみの場合
+	wait60thsec(15);
+
+	// Initialize the other parameters
+	// Random seed
+	g_rnd_seed=2463534242;
+	// Clear variables
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_mem[i]=0;
+		g_var_size[i]=0;
+	}
+	// Clear key input buffer
+	for(i=0;i<256;i++){
+		ps2keystatus[i]=0;
+	}
+	// Reset data/read.
+	reset_dataread();
+
+	// Assign memory
+	set_free_area((void*)(g_object+g_objpos),(void*)(&RAM[RAMSIZE]));
+	// Execute program
+	// Start program from the beginning of RAM.
+	// Work area (used for A-Z values) is next to the object code area.
+	start_program((void*)(&(RAM[0])),(void*)(&g_var_mem[0]));
+	printstr("\nOK\n");
+	set_graphmode(0);
+	g_use_graphic=0;
+
+	return 0;
+}

--- mips/tags/zoea1.00/compiler.c	(nonexistent)
+++ mips/tags/zoea1.00/compiler.c	(revision 148)
@@ -0,0 +1,143 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+
+void start_program(void* addr, void* memory){
+	static unsigned int stored_sp;
+	// Store s0-s7, fp, and ra in stacks
+	asm volatile("#":::"s0");
+	asm volatile("#":::"s1");
+	asm volatile("#":::"s2");
+	asm volatile("#":::"s3");
+	asm volatile("#":::"s4");
+	asm volatile("#":::"s5");
+	asm volatile("#":::"s6");
+	asm volatile("#":::"s7");
+	asm volatile("#":::"fp");
+	asm volatile("#":::"ra");
+	// Store sp in stored_sp
+	asm volatile("la $v0,%0"::"i"(&stored_sp));
+	asm volatile("sw $sp,0($v0)");
+	// Shift sp for safety
+	asm volatile("addiu $sp,$sp,-8");
+	// Register vector for unexpected NEXT/RETURN
+	asm volatile("la $v0,%0"::"i"(&err_unexp_next));
+	asm volatile("sw $v0,4($sp)");
+	// Store end address in g_end_addr
+	asm volatile("la $v0,%0"::"i"(&g_end_addr));
+	asm volatile("la $v1,label");
+	asm volatile("sw $v1,0($v0)");
+	// Set s7 for easy calling call_library()
+	asm volatile("la $s7,%0"::"i"(&call_library));
+	// Set fp and execute program
+	asm volatile("addu $fp,$zero,$a1");
+	asm volatile("jr $a0");
+	// Restore sp from stored_sp
+	asm volatile("label:");
+	asm volatile("la $v0,%0"::"i"(&stored_sp));
+	asm volatile("lw $sp,0($v0)");
+	// Restore registers from stack and return
+	return;
+}
+
+int get_gp(void){
+	asm volatile("addu $v0,$gp,$zero");
+}
+
+int get_fp(void){
+	asm volatile("addu $v0,$fp,$zero");
+}
+
+
+void shift_obj(int* src, int* dst, int len){
+	int i;
+	if (dst<src) {
+		for(i=0;i<len;i++){
+			dst[i]=src[i];
+		}
+	} else if (src<dst) {
+		for(i=len-1;0<=i;i--){
+			dst[i]=src[i];
+		}
+	}
+}
+
+int strncmp(char* str1, char* str2, int len){
+	int i;
+	for (i=0;i<len;i++) {
+		if (str1[i]>str2[i]) return 1;
+		if (str1[i]<str2[i]) return -1;
+	}
+	return 0;
+}
+
+int nextCodeIs(char* str){
+	int len;
+	for(len=0;str[len];len++);
+	if (!strncmp(g_source+g_srcpos,str,len)) {
+		if ('A'<=str[len-1] && str[len-1]<='Z') {
+			// When the last character of str is alphabet, 
+			// the next character in source must be space, enter, or ':'.
+			if (0x20<g_source[g_srcpos+len] && g_source[g_srcpos+len]!=':') return 0;
+		}
+		// String matches in the current position in source.
+		g_srcpos+=len;
+		return len;
+	} else {
+		// String didn't match.
+		return 0;
+	}
+}
+
+char* compile_line(void){
+	char b1;
+	char* err;
+	g_line++;
+	g_fileline++;
+	// Check if line number exists
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1<0x20) {
+		// The end of line.
+		// Don't add $s6-setting command.
+		if (g_source[g_srcpos]==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+		g_srcpos++;
+		return 0;
+	} else if ('0'<=b1 && b1<='9') {
+		// Line number exists
+		err=get_label();
+		if (err) return err;
+		g_line=g_label;
+	}
+	// Store line number in $s6
+	if (!(g_line&0xFFFF0000)) {
+		// Line number must be less than 65536.
+		// If not, it is invalid number.
+		// Check existing line with the same number here.
+		if (search_label(g_line)) {
+			// Error: duplicate lines
+			printstr("Line ");
+			printstr(resolve_label(g_line));
+			return ERR_MULTIPLE_LABEL;
+		}
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34160000|g_line; //ori         s6,zero,xxxx;
+	}
+	while(g_source[g_srcpos]!=0x0D && g_source[g_srcpos]!=0x0A){
+		err=statement();
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]==':') {
+			g_srcpos++;
+			next_position();
+		}
+	}
+	if (g_source[g_srcpos]==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+	g_srcpos++;
+	return 0;
+}
\ No newline at end of file

--- mips/tags/zoea1.00/file.c	(nonexistent)
+++ mips/tags/zoea1.00/file.c	(revision 148)
@@ -0,0 +1,99 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+
+static FSFILE* g_fhandle;
+static char* g_fbuff;
+static int g_size;
+
+char* init_file(char* buff,char* appname){
+	// Open file
+	g_fhandle=FSfopen(appname,"r");
+	if (!g_fhandle) {
+		return ERR_UNKNOWN;
+	}
+	g_fbuff=buff;
+	g_line=0;
+	g_fileline=0;
+	return 0;
+}
+
+void close_file(){
+	FSfclose(g_fhandle);
+}
+
+void read_file(int blocklen){
+	int i;
+	static char in_string, escape;
+	// blocklen is either 512 or 256.
+	if (blocklen==512) {
+		// This is first read. Initialize parameter(s).
+		in_string=0;
+		escape=0;
+	} else if (g_size<512) {
+		// Already reached the end of file.
+		return;
+	} else {
+		// Shift buffer and source position 256 bytes.
+		for(i=0;i<256;i++) g_fbuff[i]=g_fbuff[i+256];
+		g_srcpos-=256;
+	}
+	// Read 512 or 256 bytes from SD card.
+	g_size=512-blocklen+FSfread((void*)&g_fbuff[512-blocklen],1,blocklen,g_fhandle);
+	// Some modifications of text for easy compiling.
+	for(i=512-blocklen;i<512;i++){
+		if (in_string) {
+			if (g_fbuff[i]=='\\' && !escape) {
+				escape=1;
+			} else {
+				escape=0;
+				if (g_fbuff[i]=='"') in_string=0;
+			}
+		} else {
+			// If not in string, all upper cases.
+			if (g_fbuff[i]=='"') in_string=1;
+			else if ('a'<=g_fbuff[i] && g_fbuff[i]<='z') g_fbuff[i]+='A'-'a';
+			// If not in string, tabs will be spaces.
+			else if ('\t'==g_fbuff[i]) g_fbuff[i]=' ';
+		}
+		if (g_fbuff[i]==0x0a || g_fbuff[i]==0x0d) in_string=escape=0;
+	}
+	return;
+}
+
+char* compile_file(){
+	int i;
+	char* err;
+	// Read first 512 bytes
+	read_file(512);
+	// Compile line by line
+	while (g_size==512) {
+		err=compile_line();
+		if (err) return err;
+		// Maintain at least 256 characters in cache.
+		if (256<=g_srcpos) read_file(256);
+	}
+	// Return code at the end
+	g_source[g_size]=0x0d;
+	// Compile last few lines.
+	while(g_srcpos<g_size-1){
+		err=compile_line();
+		if (err) return err;
+	}
+	// Add "DATA 0" and "END" statements.
+	g_source="DATA 0:END\n";
+	g_srcpos=0;
+	err=compile_line();
+	if (err) return err;
+	g_srcpos=-1;
+	// No error occured
+	return 0;
+}
+

--- mips/tags/zoea1.00/compiler.h	(nonexistent)
+++ mips/tags/zoea1.00/compiler.h	(revision 148)
@@ -0,0 +1,303 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/* Definitions */
+// Number of variables (including temporary ones)
+#define ALLOC_VAR_NUM 36
+// Number of blocks that can be assigned for memory allocation (including ALLOC_VAR_NUM)
+#define ALLOC_BLOCK_NUM 48
+// Block # dedicated for PCG
+#define ALLOC_PCG_BLOCK 36
+// Block # dedicated for GRAPHIC
+#define ALLOC_GRAPHIC_BLOCK 37
+// Start # of permanent blocks
+#define ALLOC_PERM_BLOCK 38
+
+// Persistent RAM bytes used for object, heap and exception data
+#define PERSISTENT_RAM_SIZE (1024*56)
+// Exception data area bytes
+#define EXCEPTION_DATA_SIZE (64)
+// RAM size used for object and heap
+#define RAMSIZE (PERSISTENT_RAM_SIZE-EXCEPTION_DATA_SIZE)
+
+/* Enums */
+enum variable{
+	VAR_INTEGER,
+	VAR_FLOAT,
+	VAR_STRING
+};
+
+enum operator{
+	OP_VOID=0,
+	OP_OR  =1,
+	OP_AND =2,
+	OP_XOR =3,
+	OP_EQ  =4,
+	OP_NEQ =5,
+	OP_LT  =6,
+	OP_LTE =7,
+	OP_MT  =8,
+	OP_MTE =9,
+	OP_SHL =10,
+	OP_SHR =11,
+	OP_ADD =12,
+	OP_SUB =13,
+	OP_MUL =14,
+	OP_DIV =15,
+	OP_REM =16
+};
+enum libs{
+	LIB_SOUND,
+	LIB_MUSICFUNC,
+	LIB_MUSIC,
+	LIB_SETDRAWCOUNT,
+	LIB_DRAWCOUNT,
+	LIB_PALETTE,
+	LIB_GPALETTE,
+	LIB_BGCOLOR,
+	LIB_CURSOR,
+	LIB_CLS,
+	LIB_GCLS,
+	LIB_COLOR,
+	LIB_GCOLOR,
+	LIB_KEYS,
+	LIB_RESTORE,
+	LIB_RESTORE2,
+	LIB_READ,
+	LIB_MIDSTR,
+	LIB_CLEAR,
+	LIB_DIV0,
+	LIB_LETSTR,
+	LIB_STRNCMP,
+	LIB_RND,
+	LIB_DEC,
+	LIB_HEX,
+	LIB_CHR,
+	LIB_CONNECT_STRING,
+	LIB_STRING,
+	LIB_PRINTSTR,
+	LIB_LABEL,
+	LIB_DIM,
+	LIB_VAL,
+	LIB_INPUT,
+	LIB_INKEY,
+	LIB_USEPCG,
+	LIB_PCG,
+	LIB_SCROLL,
+	LIB_WAIT,
+	LIB_VAR_PUSH,
+	LIB_VAR_POP,
+	LIB_SYSTEM,
+	LIB_SPRINTF,
+	LIB_FLOAT,
+	LIB_FLOATFUNCS,
+	LIB_CREAD,
+	LIB_USEGRAPHIC,
+	LIB_GRAPHIC,
+	LIB_DEBUG
+};
+enum functions{
+	FUNC_FLOAT,
+	FUNC_INT,
+	FUNC_VALSHARP,
+	FUNC_SIN,
+	FUNC_COS,
+	FUNC_TAN,
+	FUNC_ASIN,
+	FUNC_ACOS,
+	FUNC_ATAN,
+	FUNC_SINH,
+	FUNC_COSH,
+	FUNC_TANH,
+	FUNC_EXP,
+	FUNC_LOG,
+	FUNC_LOG10,
+	FUNC_POW,
+	FUNC_SQRT,
+	FUNC_CEIL,
+	FUNC_FLOOR,
+	FUNC_FABS,
+	FUNC_MODF,
+	FUNC_FMOD,
+	FUNC_PSET,
+	FUNC_LINE,
+	FUNC_BOXFILL,
+	FUNC_CIRCLE,
+	FUNC_CIRCLEFILL,
+	FUNC_GPRINT,
+	FUNC_PUTBMP,
+	FUNC_PUTBMP2,
+	FUNC_GCOLOR,
+	FUNC_POINT,
+};
+
+/* Global vars (see globalvers.c) */
+extern int g_intconst;
+extern char g_valueisconst;
+extern int g_rnd_seed;
+extern unsigned int g_label;
+extern int g_sdepth;
+extern int g_maxsdepth;
+extern enum variable g_lastvar;
+extern char* g_source;
+extern int g_srcpos;
+extern int g_line;
+extern int g_fileline;
+extern int* g_object;
+extern int g_objpos;
+extern int* g_objmax;
+extern const char* g_err_str[];
+extern const unsigned char g_priority[];
+extern enum operator g_last_op;
+extern int g_end_addr;
+extern int g_gp;
+extern int g_s6;
+extern char RAM[RAMSIZE];
+extern unsigned int g_ex_data[EXCEPTION_DATA_SIZE/4];
+extern int g_var_mem[ALLOC_BLOCK_NUM];
+extern unsigned short g_var_pointer[ALLOC_BLOCK_NUM];
+extern unsigned short g_var_size[ALLOC_BLOCK_NUM];
+extern char g_temp_area_used;
+extern int* g_heap_mem;
+extern int g_max_mem;
+extern char g_disable_break;
+extern unsigned char* g_pcg_font;
+extern char g_use_graphic;
+extern unsigned short* g_graphic_area;
+
+/* Prototypes */
+int get_gp(void);
+int get_fp(void);
+void start_program(void* addr, void* memory);
+void shift_obj(int* src, int* dst, int len);
+char* compile_line(void);
+int nextCodeIs(char* str);
+
+char* init_file(char* buff,char* appname);
+void close_file();
+void read_file(int blocklen);
+char* compile_file();
+
+void err_break(void);
+void err_music(char* str);
+void err_data_not_found(void);
+void err_str_complex(void);
+void err_label_not_found(void);
+void err_no_mem(void);
+void err_div_zero(void);
+void err_unkonwn(void);
+void err_unexp_next(void);
+void err_no_block(void);
+char* resolve_label(int s6);
+
+void set_sound(unsigned long* data);
+int musicRemaining(void);
+void set_music(char* str);
+void init_music(void);
+
+char* statement(void);
+char* gosub_statement();
+char* graphic_statement(enum functions func);
+
+char* function(void);
+char* str_function(void);
+char* float_function(void);
+
+void call_library(void);
+void reset_dataread();
+
+void free_temp_str(char* str);
+void* alloc_memory(int size, int var_num);
+void* calloc_memory(int size, int var_num);
+void move_to_perm_block(int var_num);
+void move_from_perm_block(int var_num);
+
+char* link(void);
+char* get_label(void);
+void* search_label(unsigned int label);
+
+char* get_string();
+char* simple_string(void);
+
+char* get_operator(void);
+char* get_floatOperator(void);
+char* calculation(enum operator op);
+char* calculation_float(enum operator op);
+int lib_float(int ia0,int iv0, enum operator a1);
+
+char* get_dim_value(char b1);
+char* get_simple_value(void);
+char* get_value();
+char* get_floatOrValue();
+char* get_stringFloatOrValue();
+
+void blue_screen(void);
+
+char* get_float();
+
+/* Error messages */
+#define ERR_SYNTAX (char*)(g_err_str[0])
+#define ERR_NE_BINARY (char*)(g_err_str[1])
+#define ERR_NE_MEMORY (char*)(g_err_str[2])
+#define ERR_DIV_0 (char*)(g_err_str[3])
+#define ERR_NY_I (char*)(g_err_str[4])
+#define ERR_LABEL_NF (char*)(g_err_str[5])
+#define ERR_LABEL_LONG (char*)(g_err_str[6])
+#define ERR_STR_COMPLEX (char*)(g_err_str[7])
+#define ERR_DATA_NF (char*)(g_err_str[8])
+#define ERR_UNKNOWN (char*)(g_err_str[9])
+#define ERR_MUSIC (char*)(g_err_str[10])
+#define ERR_MULTIPLE_LABEL (char*)(g_err_str[11])
+#define ERR_BREAK (char*)(g_err_str[12])
+#define ERR_UNEXP_NEXT (char*)(g_err_str[13])
+#define ERR_NO_BLOCK (char*)(g_err_str[14])
+#define ERR_GOSUB_ASH (char*)(g_err_str[15])
+#define ERR_INVALID_BREAK (char*)(g_err_str[16])
+#define ERR_INVALID_ELSEIF (char*)(g_err_str[17])
+
+/* Macros */
+
+// Skip blanc(s) in source code
+#define next_position() while(g_source[g_srcpos]==' ') {g_srcpos++;}
+
+// Check if object area is not full.
+#define check_obj_space(x) if (g_objmax<g_object+g_objpos+(x)) return ERR_NE_BINARY
+
+// Returns priority of operator
+#define priority(x) (int)g_priority[(int)(x)]
+
+// Insert code for calling library
+//02E0F809   jalr        ra,s7
+//24070000   addiu       a3,zero,0000
+#define call_lib_code(x) \
+	check_obj_space(2);\
+	g_object[g_objpos++]=0x02E0F809;\
+	g_object[g_objpos++]=0x24070000|((x)&0x0000FFFF)
+
+// Division macro for unsigned long
+// Valid for 31 bits for all cases and 32 bits for some cases
+#define div32(x,y,z) ((((unsigned long long)((unsigned long)(x)))*((unsigned long long)((unsigned long)(y))))>>(z))
+
+// Divide by 10 (valid for 32 bits)
+#define div10_32(x) div32(x,0xcccccccd,35)
+#define rem10_32(x) ((x)-10*div10_32(x))
+
+// Divide by 36 (valid for 32 bits)
+#define div36_32(x) div32(x,0xe38e38e4,37)
+#define rem36_32(x) (x-36*div36_32(x))
+
+// Check break key or buttons when executing BASIC code.
+// In PS/2 mode, detect ctrl-break.
+// In button mode, detect pushing four buttons are pushed simultaneously.
+#define check_break() \
+	if (g_disable_break==0) {\
+		if (inPS2MODE()) {\
+			if (ps2keystatus[0x03]) err_break();\
+		} else {\
+			if ((PORTB&0x4c80)==0) err_break();\
+		}\
+	}

--- mips/tags/zoea1.00/function.c	(nonexistent)
+++ mips/tags/zoea1.00/function.c	(revision 148)
@@ -0,0 +1,517 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+#include "api.h"
+
+char* music_function(){
+	call_lib_code(LIB_MUSICFUNC);
+	return 0;
+}
+
+char* read_function(){
+	call_lib_code(LIB_READ);
+	return 0;
+}
+
+char* cread_function(){
+	call_lib_code(LIB_CREAD);
+	return 0;
+}
+
+char* gosub_function(){
+	// Check if garbage collection has been done.
+	// This check is required because the used temporary area would be changed 
+	// in sub routine. 
+	if (g_temp_area_used) return ERR_GOSUB_ASH;
+	return gosub_statement();
+}
+char* strncmp_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA40008; // lw          a0,8(sp)
+	g_object[g_objpos++]=0x8FA50004; // lw          a1,4(sp)
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	call_lib_code(LIB_STRNCMP);
+	return 0;
+}
+char* len_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(5);
+	g_object[g_objpos++]=0x2443FFFF; // addiu       v1,v0,-1
+	                                 // loop:
+	g_object[g_objpos++]=0x80640001; // lb          a0,1(v1)
+	g_object[g_objpos++]=0x1480FFFE; // bne         a0,zero,loop
+	g_object[g_objpos++]=0x24630001; // addiu       v1,v1,1
+	g_object[g_objpos++]=0x00621023; // subu        v0,v1,v0
+	return 0;
+}
+
+char* asc_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+	return 0;
+}
+
+char* val_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_VAL);
+	return 0;	
+}
+
+char* peek_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+	return 0;
+}
+
+char* sgn_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(5);
+	g_object[g_objpos++]=0x10400004; // beq         v0,zero,end
+	g_object[g_objpos++]=0x24030001; // addiu       v1,zero,1
+	g_object[g_objpos++]=0x1C400002; // bgtz        v0,end
+	g_object[g_objpos++]=0x00601021; // addu        v0,v1,zero
+	g_object[g_objpos++]=0x00031023; // subu        v0,zero,v1
+	                                 // end:
+	return 0;
+}
+
+char* abs_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x00021FC3; //sra         v1,v0,0x1f
+	g_object[g_objpos++]=0x00621026; //xor         v0,v1,v0
+	g_object[g_objpos++]=0x00431023; //subu        v0,v0,v1
+	return 0;
+}
+
+char* not_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x2C420001; //sltiu       v0,v0,1
+	return 0;
+}
+
+char* rnd_function(){
+	call_lib_code(LIB_RND);
+	return 0;
+}
+
+
+char* chr_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_CHR);
+	return 0;
+}
+char* hex_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]==',') {
+		// Second argument found.
+		// Get is as $a0.
+		g_srcpos++;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+		g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00022021; //a0,zero,v0
+		g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	} else {
+		// Second argument not found.
+		// Set $a0 to 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040000; //addiu       a0,zero,0
+	}
+	call_lib_code(LIB_HEX);
+	return 0;
+}
+
+char* dec_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_DEC);
+	return 0;
+}
+
+char* keys_function(void){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3402003F; //ori         v0,zero,0x3f
+	} else {
+		err=get_value();
+		if (err) return err;
+	}	
+	call_lib_code(LIB_KEYS);
+	return 0;
+}
+
+char* tvram_function(void){
+	char* err;
+	int i;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		i=(int)(&TVRAM[0]);
+		i-=g_gp;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27820000|(i&0x0000FFFF);       // addiu       v0,gp,xxxx
+	} else {
+		err=get_value();
+		if (err) return err;
+		i=(int)(&TVRAM[0]);
+		i-=g_gp;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x27830000|(i&0x0000FFFF);       // addiu       v1,gp,xxxx
+		g_object[g_objpos++]=0x00621821;                      // addu        v1,v1,v0
+		g_object[g_objpos++]=0x90620000;                      // lbu         v0,0(v1)
+	}	
+	return 0;
+}
+
+char* drawcount_function(void){
+	call_lib_code(LIB_DRAWCOUNT);
+	return 0;
+}
+
+char* input_function(void){
+	call_lib_code(LIB_INPUT);
+	return 0;
+}
+
+char* inkey_function(void){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x00
+	} else {
+		err=get_value();
+		if (err) return err;
+	}	
+	call_lib_code(LIB_INKEY);
+	return 0;
+}
+
+char* args_function(void){
+	char* err;
+	int i;
+	err=get_value();
+	if (err) return err;
+	i=g_object[g_objpos-1];
+	if ((i>>16)==0x3402) {
+		// Previous object is "ori v0,zero,xxxx".
+		i&=0xffff;
+		i=(i+1)<<2;
+		g_object[g_objpos-1]=0x8EA20000|i; //   lw          v0,xx(s5)
+	} else {
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00021080;   //   sll         v0,v0,0x2
+		g_object[g_objpos++]=0x02A21021;   //   addu        v0,s5,v0
+		g_object[g_objpos++]=0x8C420004;   //   lw          v0,4(v0)
+	}
+	return 0;	
+}
+
+char* system_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	g_object[g_objpos++]=0x00402021; //   addu        a0,v0,zero
+	call_lib_code(LIB_SYSTEM);
+	return 0;
+}
+
+char* sprintf_function(void){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	next_position();
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+	err=get_float();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	call_lib_code(LIB_SPRINTF);
+	return 0;
+}
+
+char* floatstr_function(void){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x0000
+	call_lib_code(LIB_SPRINTF);
+	return 0;
+}
+
+char* floatsharp_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34050000|(FUNC_FLOAT&0x0000ffff);//   ori         a1,zero,xxxx
+	call_lib_code(LIB_FLOATFUNCS);
+	return 0;
+}
+
+char* valsharp_function(void){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34050000|(FUNC_VALSHARP&0x0000ffff);//   ori         a1,zero,xxxx
+	call_lib_code(LIB_FLOATFUNCS);
+	return 0;
+}
+
+char* int_function(void){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34050000|(FUNC_INT&0x0000ffff);//   ori         a1,zero,xxxx
+	call_lib_code(LIB_FLOATFUNCS);
+	return 0;
+}
+
+char* float_constant(float val){
+	volatile int i;
+	((float*)(&i))[0]=val;
+	if (i&0xFFFF0000) {
+		// 32 bit
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+		g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+	} else {
+		// 16 bit
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+	}
+	return 0;	
+}
+
+char* float_1param_function(enum functions func){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34050000|(func&0x0000ffff);//   ori         a1,zero,xxxx
+	call_lib_code(LIB_FLOATFUNCS);
+	return 0;
+}
+
+char* float_2param_function(enum functions func){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	next_position();
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+	err=get_float();
+	if (err) return err;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	g_object[g_objpos++]=0x34050000|(func&0x0000ffff);//   ori         a1,zero,xxxx
+	call_lib_code(LIB_FLOATFUNCS);
+	return 0;
+}
+
+char* float_function(void){
+	char* err;
+	if (nextCodeIs("FLOAT#(")) {
+		err=floatsharp_function();
+	} else if (nextCodeIs("VAL#(")) {
+		err=valsharp_function();
+	} else if (nextCodeIs("SIN#(")) {
+		err=float_1param_function(FUNC_SIN);
+	} else if (nextCodeIs("COS#(")) {
+		err=float_1param_function(FUNC_COS);
+	} else if (nextCodeIs("TAN#(")) {
+		err=float_1param_function(FUNC_TAN);
+	} else if (nextCodeIs("ASIN#(")) {
+		err=float_1param_function(FUNC_ASIN);
+	} else if (nextCodeIs("ACOS#(")) {
+		err=float_1param_function(FUNC_ACOS);
+	} else if (nextCodeIs("ATAN#(")) {
+		err=float_1param_function(FUNC_ATAN);
+	} else if (nextCodeIs("SINH#(")) {
+		err=float_1param_function(FUNC_SINH);
+	} else if (nextCodeIs("COSH#(")) {
+		err=float_1param_function(FUNC_COSH);
+	} else if (nextCodeIs("TANH#(")) {
+		err=float_1param_function(FUNC_TANH);
+	} else if (nextCodeIs("EXP#(")) {
+		err=float_1param_function(FUNC_EXP);
+	} else if (nextCodeIs("LOG#(")) {
+		err=float_1param_function(FUNC_LOG);
+	} else if (nextCodeIs("LOG10#(")) {
+		err=float_1param_function(FUNC_LOG10);
+	} else if (nextCodeIs("POW#(")) {
+		err=float_2param_function(FUNC_POW);
+	} else if (nextCodeIs("SQRT#(")) {
+		err=float_1param_function(FUNC_SQRT);
+	} else if (nextCodeIs("CEIL#(")) {
+		err=float_1param_function(FUNC_CEIL);
+	} else if (nextCodeIs("FLOOR#(")) {
+		err=float_1param_function(FUNC_FLOOR);
+	} else if (nextCodeIs("FABS#(")) {
+		err=float_1param_function(FUNC_FABS);
+	} else if (nextCodeIs("MODF#(")) {
+		err=float_1param_function(FUNC_MODF);
+	} else if (nextCodeIs("FMOD#(")) {
+		err=float_2param_function(FUNC_FMOD);
+	} else if (nextCodeIs("GOSUB#(")) {
+		err=gosub_function();
+	} else if (nextCodeIs("ARGS#(")) {
+		err=args_function();
+	} else if (nextCodeIs("PI#")) {
+		return float_constant(3.141593);
+	} else {
+		return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+char* str_function(void){
+	char* err;
+	if (nextCodeIs("CHR$(")) {
+		err=chr_function();
+	} else if (nextCodeIs("HEX$(")) {
+		err=hex_function();
+	} else if (nextCodeIs("DEC$(")) {
+		err=dec_function();
+	} else if (nextCodeIs("INPUT$(")) {
+		err=input_function();
+	} else if (nextCodeIs("GOSUB$(")) {
+		err=gosub_function();
+	} else if (nextCodeIs("ARGS$(")) {
+		err=args_function();
+	} else if (nextCodeIs("READ$(")) {
+		err=read_function();
+	} else if (nextCodeIs("SPRINTF$(")) {
+		err=sprintf_function();
+	} else if (nextCodeIs("FLOAT$(")) {
+		err=floatstr_function();
+	} else if (nextCodeIs("SYSTEM$(")) {
+		err=system_function();
+	} else {
+		return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+char* function(void){
+	char* err;
+	if (nextCodeIs("NOT(")) {
+		err=not_function();
+	} else if (nextCodeIs("DRAWCOUNT(")) {
+		err=drawcount_function();
+	} else if (nextCodeIs("MUSIC(")) {
+		err=music_function();
+	} else if (nextCodeIs("TVRAM(")) {
+		err=tvram_function();
+	} else if (nextCodeIs("KEYS(")) {
+		err=keys_function();
+	} else if (nextCodeIs("READ(")) {
+		err=read_function();
+	} else if (nextCodeIs("CREAD(")) {
+		err=cread_function();
+	} else if (nextCodeIs("GOSUB(")) {
+		err=gosub_function();
+	} else if (nextCodeIs("STRNCMP(")) {
+		err=strncmp_function();
+	} else if (nextCodeIs("PEEK(")) {
+		err=peek_function();
+	} else if (nextCodeIs("LEN(")) {
+		err=len_function();
+	} else if (nextCodeIs("ASC(")) {
+		err=asc_function();
+	} else if (nextCodeIs("SGN(")) {
+		err=sgn_function();
+	} else if (nextCodeIs("ABS(")) {
+		err=abs_function();
+	} else if (nextCodeIs("RND(")) {
+		err=rnd_function();
+	} else if (nextCodeIs("VAL(")) {
+		err=val_function();
+	} else if (nextCodeIs("INKEY(")) {
+		err=inkey_function();
+	} else if (nextCodeIs("ARGS(")) {
+		err=args_function();
+	} else if (nextCodeIs("SYSTEM(")) {
+		err=system_function();
+	} else if (nextCodeIs("INT(")) {
+		err=int_function();
+	} else if (nextCodeIs("GCOLOR(")) {
+		err=graphic_statement(FUNC_GCOLOR);
+	} else {
+		return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return err;
+}

--- mips/tags/zoea1.00/string.c	(nonexistent)
+++ mips/tags/zoea1.00/string.c	(revision 148)
@@ -0,0 +1,213 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+  Public functions:
+    char* get_string(void);
+	char* simple_string(void);
+*/
+
+#include "api.h"
+#include "compiler.h"
+
+char* simple_string(void){
+	char* err;
+	unsigned char b1,b2;
+	int i,j;
+	next_position();
+	b1=g_source[g_srcpos];
+	b2=g_source[g_srcpos+1];
+	if (b1=='"') {
+		// Constant string
+		// Count character number (+1 for \0)
+		// This may be more than actual character number due to escape sequence.
+		i=0;
+		while(1){
+			i++;
+			b1=g_source[g_srcpos+i];
+			if (b1=='"') {
+				break;
+			} else if (b1=='\\') {
+				i++;
+			} else if (b1<0x20) {
+				// This is an error, that will be detected later again.
+				break;
+			}
+		};
+		g_srcpos++;
+		// Determine required word number
+		i=(i+3)/4;
+		// Determine address containing the string
+		j=(int)(&(g_object[g_objpos+3]));
+		// Note that using "bgezal zero," must be used to skip some region.
+		// This is to find embed string in the code.
+		check_obj_space(2+i);
+		g_object[g_objpos++]=0x04110000|((i+1)&0x0000FFFF);   // bgezal zero,xxxx
+		g_object[g_objpos++]=0x03E01021;                      // addu   v0,ra,zero
+		for(j=0;(b1=g_source[g_srcpos++])!='"';j++) {
+			if (b1=='\\') {
+				b1=g_source[g_srcpos++];
+				if (b1=='x' || b1=='X') {
+					// Hexadecimal
+					b1=g_source[g_srcpos++];
+					if ('0'<=b1 && b1<='9') b1=b1-'0';
+					else if ('A'<=b1 && b1<='F') b1=b1-'A'+10;
+					else if ('a'<=b1 && b1<='f') b1=b1-'a'+10;
+					else return ERR_SYNTAX;
+					b2=g_source[g_srcpos++];
+					if ('0'<=b2 && b2<='9') b2=b2-'0';
+					else if ('A'<=b2 && b2<='F') b2=b2-'A'+10;
+					else if ('a'<=b2 && b2<='f') b2=b2-'a'+10;
+					else return ERR_SYNTAX;
+					b1=(b1<<4)|b2;
+				} else if (b1<0x20) {
+					return ERR_SYNTAX;
+				} else {
+					// \\ or \"
+				}
+			} else if (b1<0x20) {
+				return ERR_SYNTAX;
+			}
+			((char*)(&g_object[g_objpos]))[j]=b1;
+		}
+		((char*)(&g_object[g_objpos]))[j]=0x00;
+		g_objpos+=i;
+	} else if ('A'<=b1 && b1<='Z' && b2=='$') {
+		// String variable
+		g_srcpos+=2;
+		next_position();
+		if (g_source[g_srcpos]=='(') {
+			// A part of string
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			if (g_source[g_srcpos]==')') {
+				g_srcpos++;
+				// Put -1 to $a0
+				check_obj_space(1);
+				g_object[g_objpos++]=0x2404FFFF;          // addiu a0,zero,-1
+			} else if (g_source[g_srcpos]==',') {
+				g_srcpos++;
+				// Store $v0 in stack
+				g_sdepth+=4;
+				if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+				check_obj_space(1);
+				g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+				// Get next value
+				err=get_value();
+				if (err) return err;
+				// Copy $v0 to $a0 and get value from stack to $a0.
+				check_obj_space(2);
+				g_object[g_objpos++]=0x00402021;          // addu a0,v0,zero
+				g_object[g_objpos++]=0x8FA20000|g_sdepth; // lw v0,xx(sp)
+				g_sdepth-=4;
+				if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+				g_srcpos++;
+				// Temp area will be used when executing.
+				g_temp_area_used=1;
+			} else {
+				return ERR_SYNTAX;
+			}
+			// $a1 is var number, $v0 is position, $a0 is length
+			check_obj_space(1);
+			g_object[g_objpos++]=0x24050000|(b1-'A'); // addiu a1,zero,xx
+			call_lib_code(LIB_MIDSTR);
+		} else {
+			// Simple string
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|((b1-'A')*4); // lw v0,xx(s8)
+			// String is pointed by $v0
+		}
+	} else if ('A'<=b1 && b1<='Z') {
+		// Function
+		// String would be pointed by $v0
+		// Otherwise, it will be assinged in xxx_function() function.
+		err=str_function();
+		if (err) return err;
+		// Temp area would be used when executing.
+		g_temp_area_used=1;
+		return 0;
+	} else {
+		return ERR_SYNTAX;
+	}
+	return 0;
+}
+
+char* get_string_sub(){
+	char* err;
+	char b1;
+	// Obtain initial string
+	err=simple_string();
+	if (err) return err;
+	// Check if connection operator exists
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1!='+' && b1!='&') return 0; // Exit if connection operator does not exist.
+	g_srcpos++;
+	// Connection required.
+	// Prepare one level of stack for handling
+	g_sdepth+=4;
+	if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+	while(1) {
+		// Store current pointer in stack
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Obtain next string (pointer will be in $v0)
+		err=simple_string();
+		if (err) return err;
+		// Restore previous pointer from stack in $a0 and copy $v0 to $a1
+		// Call library
+		check_obj_space(2);
+		g_object[g_objpos++]=0x8FA40000|g_sdepth;             // lw    a0,xx(sp)
+		call_lib_code(LIB_CONNECT_STRING);
+		// Temp area will be used when executing.
+		g_temp_area_used=1;
+		// Check if further connection operator exists
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!='+' && b1!='&') break;
+		g_srcpos++;
+	}
+	g_sdepth-=4;
+	return 0;
+}
+
+char* get_string(){
+	// This is only the public function.
+	// Note that this can be called recursively.
+	// String may contain a function with a parameter of value
+	// that is a function with a parameter of string.
+	// Result will be in $v0 as a pointer.
+	char* err;
+	char b1;
+	int i,prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_objpos++;
+	}
+	err=get_string_sub();
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+			g_objpos--;
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_STRING;
+	return 0;
+}
+

--- mips/tags/zoea1.00/statement.c	(nonexistent)
+++ mips/tags/zoea1.00/statement.c	(revision 148)
@@ -0,0 +1,1387 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "api.h"
+#include "compiler.h"
+
+char* rem_statement(){
+	if (g_source[g_srcpos-4]<0x20) {
+		// This line contains only "REM" statement
+		// Delete $s6-setting command if exists.
+		if ((g_object[g_objpos-1]&0xffff0000)==0x34160000) g_objpos--;
+	}
+	while(0x20<=g_source[g_srcpos]){
+		g_srcpos++;
+	}
+	return 0;
+}
+
+char* sound_statement(){
+	char *err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0814xxxx and 0x0815xxxx are specific codes for these.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x08140000|((g_label>>16)&0x0000FFFF); // lui   v0,xxxx
+		g_object[g_objpos++]=0x08150000|(g_label&0x0000FFFF);       // ori v0,v0,xxxx
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+	}
+	call_lib_code(LIB_SOUND);
+	return 0;
+}
+char* music_statement(){
+	char *err;
+	err=get_string();
+	call_lib_code(LIB_MUSIC);
+	return 0;
+}
+
+char* exec_statement(){
+	char *err;
+	char b1;
+	int i,prevpos;
+	b1=g_source[g_srcpos];
+	while('0'<=b1 && b1<='9' || b1=='-' || b1=='$'){
+		prevpos=g_objpos;
+		g_valueisconst=1;
+		err=get_simple_value();
+		if (!g_valueisconst) err=ERR_SYNTAX;
+		if (err) return err;
+		check_obj_space(1);
+		g_objpos=prevpos;
+		g_object[g_objpos++]=g_intconst;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!=',') break;
+		g_srcpos++;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==0x0d || b1==0x0a) {
+			// Multiline DATA/EXEC statement
+			g_line++;
+			g_fileline++;
+			if (b1==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+			g_srcpos++;
+			// Maintain at least 256 characters in cache.
+			if (256<=g_srcpos) read_file(256);
+			next_position();
+			b1=g_source[g_srcpos];
+		}			
+	}
+	return 0;
+}
+
+char* cdata_statement(){
+	// 0x00000020, 0x00000021, 0x00000022, and 0x00000023 (add/addu/sub/subu zero,zero,zero) 
+	// are the sign of data region
+	int beginpos,prevpos;
+	char* err;
+	char b1;
+	char* cpy;
+	int shift=0;
+	int i=0;
+	beginpos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x04110000; // bgezal      zero,xxxx
+	g_object[g_objpos++]=0x00000020; // add         zero,zero,zero
+	next_position();
+	b1=g_source[g_srcpos];
+	while('0'<=b1 && b1<='9' || b1=='-' || b1=='$'){
+		prevpos=g_objpos;
+		g_valueisconst=1;
+		err=get_simple_value();
+		if (!g_valueisconst) err=ERR_SYNTAX;
+		if (g_intconst<0x00 || 0xff<g_intconst) err=ERR_SYNTAX;
+		if (err) return err;
+		g_objpos=prevpos;
+		i|=g_intconst<<shift;
+		shift+=8;
+		if (32<=shift) {
+			check_obj_space(1);
+			g_object[g_objpos++]=i;
+			shift=0;
+			i=0;
+		}
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!=',') break;
+		g_srcpos++;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==0x0d || b1==0x0a) {
+			// Multiline CDATA statement
+			g_line++;
+			g_fileline++;
+			if (b1==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+			g_srcpos++;
+			// Maintain at least 256 characters in cache.
+			if (256<=g_srcpos) read_file(256);
+			next_position();
+			b1=g_source[g_srcpos];
+		}			
+	}
+	// Write the last 1-3 bytes and shift data if total # is not multipes of 4.
+	if (0<shift) {
+		// Convert shift value from bit-shift to data byte-shift.
+		shift=4-shift/8;
+		check_obj_space(1);
+		g_object[g_objpos++]=i;
+		for(cpy=(char*)&g_object[g_objpos]-1;(char*)&g_object[beginpos+2]<cpy;cpy--){
+			cpy[0]=cpy[0-shift];
+		}
+	}
+	// Determine the size of data
+	i=g_objpos-beginpos-1;
+	g_object[beginpos]  =0x04110000|i;     // bgezal zero,xxxx
+	g_object[beginpos+1]=0x00000020|shift; // add         zero,zero,zero
+	return 0;
+}
+
+char* data_statement(){
+	// 0x00000020, 0x00000021, 0x00000022, and 0x00000023 (add/addu/sub/subu zero,zero,zero) 
+	// are the sign of data region
+	int i,prevpos;
+	char* err;
+	while(1){
+		prevpos=g_objpos;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x04110000; // bgezal      zero,xxxx
+		g_object[g_objpos++]=0x00000020; // add         zero,zero,zero
+		next_position();
+		if (g_source[g_srcpos]=='"') {
+			// Constant string
+			// Store pointer to string. This is 3 words bellow of current position
+			g_object[g_objpos]=(int)(&g_object[g_objpos+3]);
+			g_objpos++;
+			g_object[prevpos]=0x04110002; // bgezal zero,xxxx
+			err=simple_string();
+			if (err) return err;
+			next_position();
+			if (g_source[g_srcpos]==',') continue;
+			return 0;
+		}
+		err=exec_statement();
+		if (err) return err;
+		// Determine the size of data
+		i=g_objpos-prevpos-1;
+		g_object[prevpos]=0x04110000|i; // bgezal zero,xxxx
+		if (g_source[g_srcpos]=='"') {
+			// Constant string
+			continue;
+		}
+		return 0;
+	}
+}
+
+char* clear_statement(){
+	call_lib_code(LIB_CLEAR);
+	return 0;
+}
+
+char* poke_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA30004; // lw          v1,4(sp)
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	g_object[g_objpos++]=0xA0620000; // sb          v0,0(v1)
+	return 0;
+}
+
+char* dim_statement(){
+	char* err;
+	char b1;
+	int spos;
+	int stack;
+	while(1){
+		stack=0;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1<'A' || 'Z'<b1) return ERR_SYNTAX;
+		g_srcpos++;
+		if (g_source[g_srcpos]=='#') g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='(') return ERR_SYNTAX;
+		check_obj_space(1);
+		spos=g_objpos++;           // addiu       sp,sp,xxxx
+		do {
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			stack+=4;
+			check_obj_space(1);
+			g_object[g_objpos++]=0xAFA20000|stack; // sw          v0,8(sp)
+		} while (g_source[g_srcpos]==',');
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x24040000|(b1-'A');  // addiu       a0,zero,xx
+		g_object[g_objpos++]=0x24050000|(stack/4); // addiu       a1,zero,xxxx
+		g_object[g_objpos++]=0x03A01025;           // or          v0,sp,zero
+		call_lib_code(LIB_DIM);
+		// Stack -/+
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BD0000|stack;     // addiu       sp,sp,xxxx
+		stack=(0-stack)&0x0000FFFF;
+		g_object[spos]=0x27BD0000|stack;           // addiu       sp,sp,xxxx
+		next_position();
+		if (g_source[g_srcpos]!=',') break;
+		g_srcpos++;
+	}
+	return 0;
+}
+
+char* label_statement(){
+	char* err;
+	char b1;
+	b1=g_source[g_srcpos];
+	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX; // Number is not allowed here.
+	err=get_label();
+	if (err) return err;
+	// Check existing label with the same name here.
+	if (search_label(g_label)) {
+		// Error: duplicate labels
+		printstr("Label ");
+		printstr(resolve_label(g_label));
+		return ERR_MULTIPLE_LABEL;
+	}
+	check_obj_space(2);
+	g_object[g_objpos++]=0x3C160000|((g_label>>16)&0x0000FFFF); //lui s6,yyyy;
+	g_object[g_objpos++]=0x36D60000|(g_label&0x0000FFFF);       //ori s6,s6,zzzz;
+	return 0;
+}
+
+char* restore_statement(){
+	char* err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Constant label/number
+		// Use 32 bit mode also for values<65536
+		// This code will be replaced to code for v0 for pointer in linker.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C020000|(g_label>>16);        // lui         v0,xxxx
+		g_object[g_objpos++]=0x34420000|(g_label&0x0000FFFF); // ori         v0,v0,xxxx
+	} else {
+		// Dynamic number
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_RESTORE);
+	return 0;
+}
+
+char* gosub_statement_sub(){
+	char* err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0812xxxx and 0x0813xxxx are specific codes for these.
+		check_obj_space(6);
+		g_object[g_objpos++]=0x04110003;                            // bgezal      zero,label1
+		g_object[g_objpos++]=0x27BDFFFC;                            // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x10000003;                            // beq         zero,zero,label2
+		g_object[g_objpos++]=0x08120000|((g_label>>16)&0x0000FFFF); // nop         
+		                                                            // label1:
+		g_object[g_objpos++]=0x08130000|(g_label&0x0000FFFF);       // j           xxxx
+		g_object[g_objpos++]=0xAFBF0004;                            // sw          ra,4(sp)
+		                                                            // label2:
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+		check_obj_space(6);
+		g_object[g_objpos++]=0x04110003; // bgezal      zero,label1
+		g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x10000003; // beq         zero,zero,label2
+		g_object[g_objpos++]=0x00000000; // nop         
+		                                 // label1:
+		g_object[g_objpos++]=0x00400008; // jr          v0
+		g_object[g_objpos++]=0xAFBF0004; // sw          ra,4(sp)
+		                                 // label2:
+	}
+	return 0;
+}
+
+char* gosub_statement(){
+	char* err;
+	int opos,spos,stack;
+	opos=g_objpos;
+	spos=g_srcpos;
+	err=gosub_statement_sub();
+	if (err) return err;
+	next_position();
+	// If there is no 2nd argument, return.
+	if (g_source[g_srcpos]!=',') return 0;
+
+	// There is (at least) 2nd argument.
+	// Rewind object and construct argument-creating routine.
+	g_objpos=opos;
+	stack=4;
+	g_object[g_objpos++]=0x27BD0000;           // addiu       sp,sp,-xx
+	do {
+		g_srcpos++;
+		stack+=4;
+		err=get_stringFloatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|stack; // sw          v0,xx(sp)
+		next_position();
+	} while(g_source[g_srcpos]==',');
+	check_obj_space(2);
+	g_object[g_objpos++]=0xAFB50004;           // sw          s5,4(sp)
+	g_object[g_objpos++]=0x03A0A821;           // addu        s5,sp,zero
+	g_object[opos]|=((0-stack)&0xFFFF);        // addiu       sp,sp,-xx (See above)
+	// Rewind source and construct GOSUB routine again.
+	opos=spos;
+	spos=g_srcpos;
+	g_srcpos=opos;
+	err=gosub_statement_sub();
+	if (err) return err;
+	// Remove stack
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FB50004;           // lw          s5,4(sp)
+	g_object[g_objpos++]=0x27BD0000|stack;     // addiu       sp,sp,xx
+	// All done, go back to wright source position
+	g_srcpos=spos;
+	return 0;
+}
+
+char* return_statement(){
+	char* err;
+	char b1;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (0x20<b1 && b1!=':') {
+		// There is a return value.
+		err=get_stringFloatOrValue();
+		if (err) return err;
+	}
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA30004; // lw          v1,4(sp)
+	g_object[g_objpos++]=0x00600008; // jr          v1
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	return 0;
+}
+
+char* goto_statement(){
+	char* err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0810xxxx and 0x0811xxxx are specific codes for these.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x08100000|((g_label>>16)&0x0000FFFF); // j xxxx
+		g_object[g_objpos++]=0x08110000|(g_label&0x0000FFFF);       // nop
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+		check_obj_space(2);
+		g_object[g_objpos++]=0x00400008; // jr          v0
+		g_object[g_objpos++]=0x00000000; // nop
+	}
+	return 0;
+}
+
+char* if_statement(){
+	char* err;
+	int prevpos,bpos;
+	// Get value.
+	err=get_floatOrValue();
+	if (err) return err;
+	// Check "THEN"
+	if (!nextCodeIs("THEN")) return ERR_SYNTAX;
+	// Check if statement follows after THEN statement
+	next_position();
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (g_source[g_srcpos]<0x20) {
+		// End of line.
+		// Use IF-THEN-ENDIF mode (multiple line mode)
+		check_obj_space(3);
+		g_object[g_objpos++]=0x30000000; // nop (see linker)
+		g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+		g_object[g_objpos++]=0x30000000; // nop (see linker)
+		return 0;
+	}
+	// One line mode
+	// If $v0=0 then skip.
+	bpos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+	g_object[g_objpos++]=0x00000000; // nop
+	prevpos=g_srcpos;
+	if (statement()) {
+		// May be label
+		g_srcpos=prevpos;
+		err=goto_statement();
+		if (err) return err;
+	} else {
+		// Must be statement(s)
+		while(1) {
+			if (g_source[g_srcpos]!=':') break;
+			g_srcpos++;
+			err=statement();
+			if (err) return err;
+		}
+	}
+	// Check if "ELSE" exists.
+	if (!nextCodeIs("ELSE ")) {
+		// "ELSE" not found. This is the end of "IF" statement.
+		// Previous branch command must jump to this position.
+		g_object[bpos]=0x10400000|(g_objpos-bpos-1); // beq         v0,zero,xxxx	
+		return 0;
+	}
+	// Skip after ELSE if required.
+	check_obj_space(2);
+	g_object[g_objpos++]=0x10000000; // beq         zero,zero,xxxx
+	g_object[g_objpos++]=0x00000000; // nop
+	// Previous branch command must jump to this position.
+	g_object[bpos]=0x10400000|(g_objpos-bpos-1); // beq         v0,zero,xxxx	
+	bpos=g_objpos-2;
+	// Next statement is either label or general statement
+	prevpos=g_srcpos;
+	if (statement()) {
+		// May be label
+		g_srcpos=prevpos;
+		err=goto_statement();
+		if (err) return err;
+	} else {
+		// Must be statement(s)
+		while(1) {
+			if (g_source[g_srcpos]!=':') break;
+			g_srcpos++;
+			err=statement();
+			if (err) return err;
+		}
+	}
+	// Previous branch command must jump to this position.
+	g_object[bpos]=0x10000000|(g_objpos-bpos-1); // beq         zero,zero,xxxx	
+	return 0;
+}
+
+char* elseif_statement(void){
+	// Multiple line mode
+	char* err;
+	g_object[g_objpos++]=0x08160100; // breakif (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	// Get value.
+	err=get_floatOrValue();
+	if (err) return err;
+	// Check "THEN"
+	if (!nextCodeIs("THEN")) return ERR_SYNTAX;
+	// Check if statement follows after THEN statement
+	next_position();
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+	g_object[g_objpos++]=0x30000000; // nop (see linker)
+	return 0;
+	
+}
+
+char* else_statement(void){
+	// Multiple line mode
+	g_object[g_objpos++]=0x08160100; // breakif (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	g_object[g_objpos++]=0x30000000; // nop (see linker)
+	// Check if statement follows after THEN statement
+	next_position();
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	return 0;
+}
+
+char* endif_statement(void){
+	// Multiple line mode
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	// Check if statement follows after THEN statement
+	next_position();
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	return 0;
+}
+
+char* end_statement(void){
+	int i;
+	i=(int)&g_end_addr;
+	i-=g_gp;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8F820000|(i&0x0000FFFF);       // lw v0,xxxx(gp)
+	g_object[g_objpos++]=0x00400008;                      // jr v0
+	g_object[g_objpos++]=0x00000000;                      // nop
+	return 0;
+}
+
+char* let_dim_sub(char b1){
+	char* err;
+	g_srcpos++;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x00021080;              // sll v0,v0,0x2
+	g_object[g_objpos++]=0x8FC30000|((b1-'A')*4); // lw    v1,xx(s8)
+	g_object[g_objpos++]=0x00621821;              // addu  v1,v1,v0
+	g_object[g_objpos++]=0xAFA30004;              // sw    v1,4(sp)
+	while(g_source[g_srcpos]==','){
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(4);
+		g_object[g_objpos++]=0x00021080;          // sll v0,v0,0x2
+		g_object[g_objpos++]=0x8FA30004;          // lw    v1,4(sp)
+		g_object[g_objpos++]=0x8C630000;          // lw    v1,0(v1)
+		g_object[g_objpos++]=0x00621821;          // addu  v1,v1,v0
+		g_object[g_objpos++]=0xAFA30004;          // sw    v1,4(sp)
+	}
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+};
+
+char* let_statement(){
+	char* err;
+	char b1,b2,b3;
+	int i;
+	next_position();
+	b1=g_source[g_srcpos];
+	b2=g_source[g_srcpos+1];
+	b3=g_source[g_srcpos+2];
+	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX;
+	g_srcpos++;
+	if (b2=='#' && b3=='(') {
+		// Float dimension
+		g_srcpos++;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+		let_dim_sub(b1);
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+		g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+		g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+		return 0;
+	} else if (b2=='#') {
+		// Float A-Z
+		g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFC20000|((b1-'A')*4); // sw v0,xxx(s8)
+		return 0;
+	} else 	if (b2=='$') {
+		// String
+		g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040000|(b1-'A'); //addiu       a0,zero,xx
+		call_lib_code(LIB_LETSTR);
+		return 0;
+	} else if (b2=='(') {
+		// Dimension
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+		let_dim_sub(b1);
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+		g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+		g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+		return 0;
+	} else {
+		// Integer A-Z
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFC20000|((b1-'A')*4); // sw v0,xxx(s8)
+	}
+	return 0;
+}
+
+char* print_statement(){
+	char* err;
+	char b1;
+	int i;
+	int status=0;// 1:',' 2:';' 0:none
+	while(1){
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1<0x20 || b1==':') break;
+		if (!strncmp(g_source+g_srcpos,"ELSE "  ,5)) break;	
+		err=get_stringFloatOrValue();
+		if (err) return err;
+		switch(g_lastvar){
+			case VAR_INTEGER:
+				// Use DEC$() function.
+				call_lib_code(LIB_DEC);
+				break;
+			case VAR_FLOAT:
+				// Use FLOAT$() function.
+				check_obj_space(2);
+				g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+				g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x0000
+				call_lib_code(LIB_SPRINTF);
+				break;
+			case VAR_STRING:
+			default:
+				break;
+		}
+		// Call printstr() function
+		// First argument is the pointer to string
+		call_lib_code(LIB_PRINTSTR);
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==',') {
+			status=1;
+			g_srcpos++;
+			// Call lib_string() function for comma (,)
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34040001;                      // ori   a0,zero,1
+			call_lib_code(LIB_STRING);
+		} else if (b1==';') {
+			status=2;
+			g_srcpos++;
+		} else {
+			status=0;
+		}
+	}
+	if (status==0) {
+		// Call lib_string() function for CR (\n)
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34040000;                      // ori   a0,zero,0
+		call_lib_code(LIB_STRING);
+	}
+	return 0;
+}
+
+char* break_statement(){
+	check_obj_space(2);
+	g_object[g_objpos++]=0x08160000; // j           xxxx     (See link() function)
+	g_object[g_objpos++]=0x00000000; // nop
+	return 0;
+}
+
+char* for_statement(){
+	char* err;
+	char b1;
+	// Initialization of variable
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX;
+	err=let_statement();
+	if (err) return err;
+	// Check if "TO" exists
+	next_position();
+	if (!nextCodeIs("TO ")) return ERR_SYNTAX;
+	err=get_value();
+	if (err) return err;
+	// Usage of stack:
+	//   12(sp): "TO" value
+	//    8(sp): "STEP" value
+	//    4(sp): Address to return to in "NEXT" statement.
+	// Store "TO" value in stack
+	check_obj_space(2);
+	g_object[g_objpos++]=0x0820FFF4; // addiu sp,sp,-12 (see linker)
+	g_object[g_objpos++]=0xAFA2000C; // sw v0,12(sp)
+	// Check if "STEP" exists
+	next_position();
+	g_valueisconst=1;
+	if (nextCodeIs("STEP ")) {
+		// "STEP" exists. Get value
+		err=get_value();
+		if (err) return err;
+	} else {
+		// "STEP" not exist. Use "1".	
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020001; // addiu v0,zero,1
+		g_intconst=1;
+	}
+	check_obj_space(14);
+	g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(sp)       (STEP value)
+	g_object[g_objpos++]=0x04110004;              // bgezal      zero,check
+	g_object[g_objpos++]=0x8FC40000|((b1-'A')*4); // lw          a0,xx(s8)      (current var value)
+	// After executing "NEXT" statement, process reaches following line.
+	// Update variable value by adding STEP value
+	// Note that STEP value is loaded onto $v0 in NEXT statement
+	g_object[g_objpos++]=0x8FC40000|((b1-'A')*4); // lw          a0,xx(s8)      (current var value)
+	g_object[g_objpos++]=0x00822021;              // addu        a0,a0,v0
+	g_object[g_objpos++]=0xAFC40000|((b1-'A')*4); // sw          a0,xx(s8)      (new var value)
+	// Value-checking routine and storing ra in stack
+	                                              // check:
+	g_object[g_objpos++]=0x8FA3000C;              // lw          v1,12(sp)      (TO value)
+	g_object[g_objpos++]=0x00641823;              // subu        v1,v1,a0
+	g_object[g_objpos++]=0x04420001;              // bltzl       v0,negative
+	g_object[g_objpos++]=0x00031823;              // subu        v1,zero,v1
+	                                              // negative:
+	g_object[g_objpos++]=0x04610003;              // bgez        v1,continue
+	g_object[g_objpos++]=0xAFBF0004;              // sw          ra,4(sp)
+	break_statement();                            // (2 words)
+	                                              // continue:
+	return 0;
+}
+
+char* next_statement(){
+	// Return to address stored in 4($sp)
+	// while set $v0 to 8($sp) (see for_statement) 
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x8FA20008; // lw          v0,8(sp)       (STEP value)
+	g_object[g_objpos++]=0x0830000C; // addiu       sp,sp,12 (see linker)
+	return 0;
+}
+
+char* do_statement(){
+	char* err;
+	// Usage of stack:
+	//    4(sp): Address to return to in "DO" statement.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x04110001;//   bgezal      zero,label1:
+	g_object[g_objpos++]=0x0822FFFC;//   addiu       sp,sp,-4 (see linker)
+	                                //   label1:
+	g_object[g_objpos++]=0xAFBF0004;//   sw          ra,4(sp)
+	next_position();
+	if (nextCodeIs("WHILE ")) {
+		// DO WHILE
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x14400003; // bne         v0,zero,labe2
+		g_object[g_objpos++]=0x00000000; // nop
+		return break_statement();        // (2 words)
+			                             // label2:
+
+	} else if (nextCodeIs("UNTIL ")) {
+		// DO UNTIL
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x10400003; // beq         v0,zero,label2
+		g_object[g_objpos++]=0x00000000; // nop
+		return break_statement();        // (2 words)
+			                             // label2:
+	} else {
+		// DO statement without WHILE/UNTIL
+		return 0;
+	}
+}
+
+char* loop_statement(){
+	char* err;
+	next_position();
+	if (nextCodeIs("WHILE ")) {
+		// LOOP WHILE
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x10400003; // beq         v0,zero,label1
+	} else if (nextCodeIs("UNTIL ")) {
+		// LOOP UNTIL
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x14400003; // bne         v0,zero,label
+	} else {
+		// LOOP statement without WHILE/UNTIL
+	}
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x00000000; // nop
+	                                 // label1:
+	g_object[g_objpos++]=0x08320004; // addiu       sp,sp,4       (See link() function)
+	return 0;
+}
+
+char* while_statement(){
+	char* err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x04110001; // bgezal      zero,label1:
+	g_object[g_objpos++]=0x0821FFFC; // addiu       sp,sp,-4 (see linker)
+	                                 // label1:
+	g_object[g_objpos++]=0xAFBF0004; // sw          ra,4(sp)
+	err=get_floatOrValue();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x14400003; // bne         v0,zero,label2
+	g_object[g_objpos++]=0x00000000; // nop
+	return break_statement();        // (2 words)
+		                             // label2:
+}
+
+char* wend_statement(){
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x00000000; // nop
+	                                 // label1:
+	g_object[g_objpos++]=0x08310004; // addiu       sp,sp,4       (See link() function)
+	return 0;
+}
+
+char* palette_statement(enum libs lib){
+	// lib is either LIB_PALETTE or LIB_GPALETTE
+	// PALETTE N,R,G,B
+	char* err;
+	// Get N
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF4; // addiu       sp,sp,-12
+	g_object[g_objpos++]=0xAFA2000C; // sw          v0,12(sp)
+	// Get R
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get G
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get B
+	err=get_value();
+	if (err) return err;
+	check_obj_space(6);
+	g_object[g_objpos++]=0x8FA40008; // lw          a0,8(sp)
+	g_object[g_objpos++]=0x00042400; // sll         a0,a0,0x10
+	g_object[g_objpos++]=0x8FA50004; // lw          a1,4(sp)
+	g_object[g_objpos++]=0x00A42825; // or          a1,a1,a0
+	g_object[g_objpos++]=0x8FA4000C; // lw          a0,12(sp)
+	g_object[g_objpos++]=0x27BD000C; // addiu       sp,sp,12
+	// a0=N, a1=(R<<16)|G, v0=B
+	call_lib_code(lib);
+	return 0;
+}
+
+char* param3_statement(enum libs lib){
+	char* err;
+	// Get 1st parameter
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 2nd parameter
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 3rd parameter
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA40008; // lw          a0,8(sp)
+	g_object[g_objpos++]=0x8FA50004; // lw          a1,4(sp)
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	// a0=1st, a1=2nd, v0=3rd
+	call_lib_code(lib);
+	return 0;
+}
+
+char* bgcolor_statement(){
+	// BGCOLOR R,G,B
+	return param3_statement(LIB_BGCOLOR);
+}
+
+char* pcg_statement(){
+	// PCG ASCII,D1,D2
+	return param3_statement(LIB_PCG);
+}
+
+char* usepcg_statement(){
+	int objpos=g_objpos;
+	if (get_value()) {
+		// Getting integer failed.
+		// It supporsed to be not parameter
+		// and same as parameter=1.
+		g_objpos=objpos;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020001; //ori         v0,zero,0x01
+	}
+	call_lib_code(LIB_USEPCG);
+	return 0;
+}
+
+char* usegraphic_statement(){
+	int objpos=g_objpos;
+	if (get_value()) {
+		// Getting integer failed.
+		// It supporsed to be not parameter
+		// and same as parameter=1.
+		g_objpos=objpos;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020001; //ori         v0,zero,0x01
+	}
+	call_lib_code(LIB_USEGRAPHIC);
+	return 0;
+}
+
+char* cls_statement(){
+	call_lib_code(LIB_CLS);
+	return 0;
+}
+
+char* gcls_statement(){
+	call_lib_code(LIB_GCLS);
+	return 0;
+}
+
+char* color_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_COLOR);
+	return 0;
+}
+
+char* gcolor_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_GCOLOR);
+	return 0;
+}
+
+char* param2_statement(enum libs lib){
+	char* err;
+	// Get 1st
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd
+	err=get_value();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FA40004; // lw          a0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	call_lib_code(lib);
+	return 0;
+}
+
+char* system_statement(){
+	// SYSTEM X,Y
+	return param2_statement(LIB_SYSTEM);
+}
+
+char* cursor_statement(){
+	// CURSOR X,Y
+	return param2_statement(LIB_CURSOR);
+}
+
+char* scroll_statement(){
+	// SCROLL X,Y
+	return param2_statement(LIB_SCROLL);
+}
+
+char* drawcount_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SETDRAWCOUNT);
+	return 0;
+}
+
+char* wait_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_WAIT);
+	return 0;
+}
+char* var_statement(){
+	// Clear flags
+	unsigned int flags=0;
+	// Prepare stack
+	// Note that 12 bytes is used in lib_var()
+	// Another 4 bytes is used for return address
+	short stack=12;
+	char b;
+	do {
+		// Seek variable
+		next_position();
+		b=g_source[g_srcpos++];
+		if (b<'A' || 'Z'<b) return ERR_SYNTAX;
+		flags|=1<<(b-'A');
+		stack+=4;
+		// Support float and string variables
+		b=g_source[g_srcpos];
+		if (b=='#' || b=='$') g_srcpos++;
+		// Seek ',' or end of statement
+		next_position();
+		b=g_source[g_srcpos++];
+	} while(b==',');
+	g_srcpos--;
+	// Jump to push routine, first
+	check_obj_space(2);
+	g_object[g_objpos++]=0x04110007;                    // bgezal      zero,label1
+	g_object[g_objpos++]=0x27BD0000|((0-stack)&0xffff); // addiu       sp,sp,-xx
+	// Process will be here after RETURN statement
+	// Pop routine
+	check_obj_space(1);
+	g_object[g_objpos++]=0x03A02821;                    // addu        a1,sp,zero
+	call_lib_code(LIB_VAR_POP);
+	// Restore stack and return
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FA30000|stack;              // lw          v1,xx(sp)
+	g_object[g_objpos++]=0x00600008;                    // jr          v1
+	g_object[g_objpos++]=0x27BD0000|stack;              // addiu       sp,sp,xx
+	// Push rotine
+	check_obj_space(4);                                 // label1:
+	g_object[g_objpos++]=0xAFBF0004;                    // sw          ra,4(sp)
+	g_object[g_objpos++]=0x03A02821;                    // addu        a1,sp,zero
+	g_object[g_objpos++]=0x3C040000|(flags>>16);        // lui         a0,XXXX
+	g_object[g_objpos++]=0x34840000|(flags&0xffff);     // ori         a0,a0,XXXX
+	call_lib_code(LIB_VAR_PUSH);
+	return 0;
+}
+
+char* graphic_statement(enum functions func){
+	/*
+		PSET X1,Y1[,C]
+		LINE X1,Y1,X2,Y2[,C]
+		BOXFILL X1,Y1,X2,Y2[,C]
+		CIRCLE X1,Y1,R[,C]
+		CIRCLEFILL X1,Y1,R[,C]
+		GPRINT X1,Y1,C,BC,S$
+		PUTBMP X1,Y1,M,N,BMP
+		$a0 cotains func (8 bits), X1 (12 bits) and Y1 (12 bits)
+		$a1 contains X2/R (12 bits) and Y2 (12 bits)
+		$v0 contains C/S$/BMP (32 bits)
+	*/
+	char* err;
+	int paramnum;
+	switch(func){
+		case FUNC_PSET:// X1,Y1[,C]
+		case FUNC_GCOLOR:// X1,Y1
+		case FUNC_POINT:// X1,Y1
+			paramnum=2;
+			break;
+		case FUNC_CIRCLE:// X1,Y1,R[,C]
+		case FUNC_CIRCLEFILL:// X1,Y1,R[,C]
+			paramnum=3;
+			break;
+		case FUNC_LINE:// X1,Y1,X2,Y2[,C]
+		case FUNC_BOXFILL:// X1,Y1,X2,Y2[,C]
+			paramnum=4;
+			break;
+		case FUNC_GPRINT:// X1,Y1,C,BC,S$
+		case FUNC_PUTBMP:// X1,Y1,M,N,BMP
+			paramnum=5;
+			break;
+		default:
+			return ERR_UNKNOWN;
+	}
+
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		// X1 and Y1 is omitted. Set 0x800 for both.
+		check_obj_space(4);
+		g_object[g_objpos++]=0x27BDFFF8;              // addiu       sp,sp,-8
+		g_object[g_objpos++]=0x3C020080;              // lui         v0,0x0080
+		g_object[g_objpos++]=0x34420800;              // ori         v0,v0,0x0800
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+	} else {
+		// X1
+		err=get_value();
+		if (err) return err;
+		check_obj_space(4);
+		g_object[g_objpos++]=0x27BDFFF8;              // addiu       sp,sp,-8
+		g_object[g_objpos++]=0x30420FFF;              // andi        v0,v0,0xfff
+		g_object[g_objpos++]=0x00021300;              // sll         v0,v0,0xc
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+		// Y1
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(4);
+		g_object[g_objpos++]=0x30420FFF;              // andi        v0,v0,0xfff
+		g_object[g_objpos++]=0x8FA40004;              // lw          a0,4(sp)
+		g_object[g_objpos++]=0x00441025;              // or          v0,v0,a0
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+	}
+	if (2<paramnum) {
+		// X2, R, or M
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x30420FFF;          // andi        v0,v0,0xfff
+		g_object[g_objpos++]=0x00021300;          // sll         v0,v0,0xc
+		g_object[g_objpos++]=0xAFA20008;          // sw          v0,8(sp)
+		if (3<paramnum) {
+			// X2, BC, or N
+			if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			check_obj_space(4);
+			g_object[g_objpos++]=0x30420FFF;      // andi        v0,v0,0xfff
+			g_object[g_objpos++]=0x8FA40008;      // lw          a0,8(sp)
+			g_object[g_objpos++]=0x00441025;      // or          v0,v0,a0
+			g_object[g_objpos++]=0xAFA20008;      // sw          v0,8(sp)
+		}
+	}
+	if (func==FUNC_GPRINT) {
+		// S$
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+		if (err) return err;
+	} else if (func==FUNC_PUTBMP) {
+		// BMP
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_label();
+		if (g_label && !err) {
+			// Label/number is constant.
+			// Linker will change following codes later.
+			// Note that 0x0814xxxx and 0x0815xxxx are specific codes for these.
+			check_obj_space(2);
+			g_object[g_objpos++]=0x08140000|((g_label>>16)&0x0000FFFF); // lui   v0,xxxx
+			g_object[g_objpos++]=0x08150000|(g_label&0x0000FFFF);       // ori v0,v0,xxxx
+			// Change func to FUNC_PUTBMP2 (label mode).
+			func=FUNC_PUTBMP2;
+		} else {
+			err=get_value();
+			if (err) return err;
+		}
+	} else {
+		// [,C]
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+		} else {
+			// If C is omitted, use -1.
+			check_obj_space(1);
+			g_object[g_objpos++]=0x2402FFFF;      // addiu       v0,zero,-1
+		}
+	}
+	// Prepare $a0
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34040000|(func&0x0ff); // ori         a0,zero,xxxx
+	g_object[g_objpos++]=0x00042600;              // sll         a0,a0,0x18
+	g_object[g_objpos++]=0x8FA30004;              // lw          v1,4(sp)
+	g_object[g_objpos++]=0x00832025;              // or          a0,a0,v1
+	// Prepare $a1
+	g_object[g_objpos++]=0x8FA50008;              // lw          a1,8(sp)
+	// Restore stack pointer
+	g_object[g_objpos++]=0x27BD0008;              // addiu       sp,sp,8
+	// Call library
+	call_lib_code(LIB_GRAPHIC);
+	return 0;
+}
+#ifdef __DEBUG
+	char* debug_statement(){
+		call_lib_code(LIB_DEBUG);
+		return 0;
+	}
+#endif
+
+
+char* statement(void){
+	char* err;
+	int prevpos;
+	next_position();
+	// Clear flag for temp area usage.
+	g_temp_area_used=0;
+	// Initialize stack handler used for value
+	g_sdepth=g_maxsdepth=0;
+	if (nextCodeIs("REM")) {
+		err=rem_statement();
+	} else if (nextCodeIs("SOUND ")) {
+		err=sound_statement();
+	} else if (nextCodeIs("MUSIC ")) {
+		err=music_statement();
+	} else if (nextCodeIs("DRAWCOUNT ")) {
+		err=drawcount_statement();
+	} else if (nextCodeIs("CURSOR ")) {
+		err=cursor_statement();
+	} else if (nextCodeIs("PALETTE ")) {
+		err=palette_statement(LIB_PALETTE);
+	} else if (nextCodeIs("GPALETTE ")) {
+		err=palette_statement(LIB_GPALETTE);
+	} else if (nextCodeIs("BGCOLOR ")) {
+		err=bgcolor_statement();
+	} else if (nextCodeIs("CLS")) {
+		err=cls_statement();
+	} else if (nextCodeIs("GCLS")) {
+		err=gcls_statement();
+	} else if (nextCodeIs("COLOR ")) {
+		err=color_statement();
+	} else if (nextCodeIs("GCOLOR ")) {
+		err=gcolor_statement();
+	} else if (nextCodeIs("RESTORE ")) {
+		err=restore_statement();
+	} else if (nextCodeIs("DATA ")) {
+		err=data_statement();
+	} else if (nextCodeIs("CDATA ")) {
+		err=cdata_statement();
+	} else if (nextCodeIs("LABEL ")) {
+		err=label_statement();
+	} else if (nextCodeIs("DIM ")) {
+		err=dim_statement();
+	} else if (nextCodeIs("CLEAR")) {
+		err=clear_statement();
+	} else if (nextCodeIs("PRINT")) {
+		err=print_statement();
+	} else if (nextCodeIs("IF ")) {
+		err=if_statement();
+	} else if (nextCodeIs("ELSEIF ")) {
+		err=elseif_statement();
+	} else if (nextCodeIs("ELSE")) {
+		err=else_statement();
+	} else if (nextCodeIs("ENDIF")) {
+		err=endif_statement();
+	} else if (nextCodeIs("END")) {
+		err=end_statement();
+	} else if (nextCodeIs("EXEC ")) {
+		err=exec_statement();
+	} else if (nextCodeIs("GOTO ")) {
+		err=goto_statement();
+	} else if (nextCodeIs("GOSUB ")) {
+		err=gosub_statement();
+	} else if (nextCodeIs("RETURN")) {
+		err=return_statement();
+	} else if (nextCodeIs("POKE ")) {
+		err=poke_statement();
+	} else if (nextCodeIs("FOR ")) {
+		err=for_statement();
+	} else if (nextCodeIs("NEXT")) {
+		err=next_statement();
+	} else if (nextCodeIs("LET ")) {
+		err=let_statement();
+	} else if (nextCodeIs("PCG ")) {
+		err=pcg_statement();
+	} else if (nextCodeIs("USEPCG")) {
+		err=usepcg_statement();
+	} else if (nextCodeIs("SCROLL ")) {
+		err=scroll_statement();
+	} else if (nextCodeIs("WAIT ")) {
+		err=wait_statement();
+	} else if (nextCodeIs("USEGRAPHIC")) {
+		err=usegraphic_statement();
+	} else if (nextCodeIs("PSET ")) {
+		err=graphic_statement(FUNC_PSET);
+	} else if (nextCodeIs("LINE ")) {
+		err=graphic_statement(FUNC_LINE);
+	} else if (nextCodeIs("BOXFILL ")) {
+		err=graphic_statement(FUNC_BOXFILL);
+	} else if (nextCodeIs("CIRCLE ")) {
+		err=graphic_statement(FUNC_CIRCLE);
+	} else if (nextCodeIs("CIRCLEFILL ")) {
+		err=graphic_statement(FUNC_CIRCLEFILL);
+	} else if (nextCodeIs("GPRINT ")) {
+		err=graphic_statement(FUNC_GPRINT);
+	} else if (nextCodeIs("PUTBMP ")) {
+		err=graphic_statement(FUNC_PUTBMP);
+	} else if (nextCodeIs("POINT ")) {
+		err=graphic_statement(FUNC_POINT);
+	} else if (nextCodeIs("VAR ")) {
+		err=var_statement();
+	} else if (nextCodeIs("DO")) {
+		err=do_statement();
+	} else if (nextCodeIs("LOOP")) {
+		err=loop_statement();
+	} else if (nextCodeIs("WHILE ")) {
+		err=while_statement();
+	} else if (nextCodeIs("WEND")) {
+		err=wend_statement();
+	} else if (nextCodeIs("BREAK")) {
+		err=break_statement();
+	} else if (nextCodeIs("SYSTEM")) {
+		err=system_statement();
+#ifdef __DEBUG
+	} else if (nextCodeIs("DEBUG")) {
+		err=debug_statement();
+#endif
+	} else {
+		err=let_statement();
+	}
+	if (err) return err;
+	// Stack handler must be zero here.
+	if (g_sdepth!=0) return ERR_UNKNOWN;
+	// Check if temp area is used
+	if (g_temp_area_used) {
+		// Temp area is used. Insert a garbage collection flag setting routine.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x7ED6F000;//   ext         s6,s6,0,31
+	}
+	return 0;
+}

--- mips/tags/zoea1.00/linker.c	(nonexistent)
+++ mips/tags/zoea1.00/linker.c	(revision 148)
@@ -0,0 +1,368 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+
+unsigned int g_label;
+
+char* get_label(void){
+	unsigned int i;
+	char b1;
+	int prevpos;
+	next_position();
+	prevpos=g_srcpos;
+	i=0;
+	b1=g_source[g_srcpos];
+	if ('0'<= b1 && b1<='9') {
+		// May be line number
+		do {
+			i*=10;
+			i+=b1-'0';
+			g_srcpos++;
+			b1=g_source[g_srcpos];
+		} while ('0'<= b1 && b1<='9');
+		// Check if end of the statement.
+		if (i==0 || 65535<i) {
+			// Line number 0 or more than 65535 is not available
+			g_srcpos=prevpos;
+			return ERR_SYNTAX;
+		} else if (get_operator()) {
+			// Oparator not found.
+			g_label=i;
+			return 0;
+		} else {
+			// This is not constant line number.
+			g_srcpos=prevpos;
+			g_label=0;
+			return 0;
+		}
+	} else if ('A'<=b1 && b1<='Z') {
+		// May be label
+		do {
+			// First character must be A-Z
+			// From second, A-Z and 0-9 can be used.
+			i*=36;
+			if ('0'<=b1 && b1<='9') {
+				i+=b1-'0';
+			} else if (g_srcpos==prevpos) {
+				// First character must be A-Z.
+				// Subtract 9, resulting 1-26 but not 10-35.
+				// This subtraction is required to maintain
+				// final number being <0x80000000.
+				i+=b1-'A'+1;
+			} else {
+				i+=b1-'A'+10;
+			}
+			g_srcpos++;
+			b1=g_source[g_srcpos];
+		} while ('0'<= b1 && b1<='9' || 'A'<=b1 && b1<='Z');
+		// Length of the label must be between 2 and 6.
+		if (g_srcpos-prevpos<2 || 6<g_srcpos-prevpos) {
+			g_srcpos=prevpos;
+			return ERR_LABEL_LONG;
+		}
+		// Must not be a function
+		next_position();
+		if (g_source[g_srcpos]=='(') {
+			g_srcpos=prevpos;
+			g_label=0;
+			return 0;
+		}
+		g_label=i+65536;
+		return 0;
+	} else {
+		g_label=0;
+		return 0;
+	}
+}
+
+void* search_label(unsigned int label){
+	unsigned int i,code,search1,search2;
+	if (label&0xFFFF0000) {
+		// Label
+		search1=0x3C160000|((label>>16)&0x0000FFFF); //lui s6,yyyy;
+		search2=0x36D60000|(label&0x0000FFFF);       //ori s6,s6,zzzz;
+		for(i=0;i<g_objpos;i++){
+			code=g_object[i];
+			if (code==search1) {
+				if (g_object[i+1]==search2) {
+					// Label number found
+					return &(g_object[i]);
+				}
+			}
+			if (code&0xFFFF0000==0x04110000) {
+				// "bgezal zero," assembly found. Skip following block (strig).
+				i+=code&0x0000FFFF;
+				i--;
+			}
+		}
+		// Line number not found.
+		return 0;
+	} else {
+		// Line number
+		search1=0x34160000|label; //ori         s6,zero,xxxx;
+		for(i=0;i<g_objpos;i++){
+			code=g_object[i];
+			if (code==search1) {
+				// Line number found
+				return &(g_object[i]);
+			}
+			if (code&0xFFFF0000==0x04110000) {
+				// "bgezal zero," assembly found. Skip following block (strig).
+				i+=code&0x0000FFFF;
+				i--;
+			}
+		}
+		// Line number not found.
+		return 0;
+	}
+}
+
+void* search_breakout(unsigned int start){
+	unsigned int pos,code1,depth;
+	// Start search from start point where BREAK statement is used.
+	depth=0;
+	for(pos=start;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				pos--;
+				break;
+			case 0x0820: // FOR
+			case 0x0821: // WHILE
+			case 0x0822: // DO
+				depth++;
+				break;
+			case 0x0830: // NEXT
+			case 0x0831: // WEND
+			case 0x0832: // LOOP
+				if (0<depth) {
+					depth--;
+					break;
+				}
+				// Destination found.
+				return (void*)&g_object[pos];
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+void* search_ifout(unsigned int start){
+	unsigned int pos,code1,depth;
+	// Start search from start point where BREAK statement is used.
+	depth=0;
+	for(pos=start;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				pos--;
+				break;
+			case 0x3000: // Block marker
+				if (code1&0x00008000) {
+					// end block
+					if (0<depth) {
+						depth--;
+						break;
+					}
+					// Destination found.
+					return (void*)&g_object[pos];
+				} else {
+					// begin block
+					depth++;
+				}
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+/*
+	Following codes are dedicated to specific use:
+	0x0810xxxx, 0x0811xxxx: GOTO statement
+	0x0812xxxx, 0x0813xxxx: GOSUB statement
+	0x0814xxxx, 0x0815xxxx: SOUND etc, for setting v0 as pointer to DATA array.
+	0x0816xxxx: BREAK statemant and relatives
+		0x08160000: BREAK
+		0x08160100: Jump to next ELSE, ELSEIF or ENDIF
+	0x082xyyyy: Begin block (FOR/DO/WHILE)
+	0x083xyyyy: End block (NEXT/LOOP/WEND)
+	0x00000020, 0x00000021,
+	0x00000022, 0x00000023: Marker for begining the DATA region.
+	                        MLB 2 bits show skip byte length in DATA.
+	0x30000000: Begin block (IF-THEN-ELSEIF-ELSE-ENDIF)
+	0x30008000: End block (IF-THEN-ELSEIF-ELSE-ENDIF)
+
+	IF-THEN-ELSEIF-ELSE-ENDIF is written as follows:
+		IF-THEN: 0x30000000 0x10400000 0x30000000
+		ELSEIF-THEN: 0x08160100 0x30008000 (conditional expression) 0x10400000 0x30000000
+		ELSE: 0x08160100 0x30008000 0x30000000
+		ENDIF: 0x30008000 0x30008000 
+	, where "0x10400000 0x30000000" and "0x08160100 0x30008000" will be replaced by
+	codes jumping to next 0x30008000. The 0x30000000 - 0x30008000 blocks will be skipped.
+*/
+
+char* link(void){
+	int pos;
+	unsigned int code1,code2,label;
+	g_fileline=0;
+	for(pos=0;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				pos--;
+				break;
+			case 0x3416:
+				// "ori s6,zero,xxxx" found this is the first word in a line.
+				g_fileline++;
+				g_line=code1&0x0000FFFF;
+				break;
+			case 0x0810:
+				// GOTO
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08110000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code1=(int)search_label(label);
+				g_label=label;
+				if (!code1) return ERR_LABEL_NF;
+				code1&=0x0FFFFFFF;
+				code1>>=2;
+				code1|=0x08000000; // j xxxx
+				g_object[pos++]=code1;
+				g_object[pos]=0x00000000; // nop
+				break;
+			case 0x0812:
+				// GOSUB
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08130000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code2=(int)search_label(label);
+				g_label=label;
+				if (!code2) return ERR_LABEL_NF;
+				code2&=0x0FFFFFFF;
+				code2>>=2;
+				code2|=0x08000000; // j xxxx
+				g_object[pos++]=0x00000000; // nop
+				g_object[pos]=code2;
+				break;
+			case 0x0814:
+				// SOUND etc, for setting v0 as pointer to label/line
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08150000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code1=(int)search_label(label);
+				g_label=label;
+				if (!code1) return ERR_LABEL_NF;
+				g_object[pos++]=0x3C020000|((code1>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[pos]  =0x34420000|(code1&0x0000FFFF);       // ori v0,v0,xxxx
+				break;
+			case 0x0816:
+				switch(code1&0xFFFF) {
+					case 0x0000:
+						// BREAK statement
+						// Find next the NEXT or WHILE statement and insert jump code after this.
+						g_label=g_line;
+						code1=(int)search_breakout(pos);
+						if (!code1) return ERR_INVALID_BREAK;
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					case 0x0100:
+						// Jump to next ENDIF
+						g_label=g_line;
+						// "pos+2" is for skipping next code (must be 0x30008000)
+						code1=(int)search_ifout(pos+2);
+						if (!code1) return ERR_INVALID_ELSEIF;
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					default:
+						break;
+				}
+				break;
+			case 0x3000:
+				// Block marker
+				switch(code1&0xFFFF) {
+					case 0x0000:
+						// Begin if block
+						if (g_object[pos-1]==0x10400000) { // beq v0,zero,xxxx
+							// IF-THEN or ELSEIF-THEN
+							// Jump to next ELSE, ELSEIF or ENDIF
+							g_label=g_line;
+							// "pos+1" is for skipping current code (0x30000000)
+							code1=(int)search_ifout(pos+1);
+							if (!code1) return ERR_INVALID_ELSEIF;
+							code1-=(int)(&g_object[pos]);
+							code1>>=2;
+							code1&=0x0000FFFF;
+							code1|=0x10400000; // beq v0,zero,xxxx
+							g_object[pos-1]=code1;
+							break;
+						}
+						break;
+					default:
+						break;
+				}
+				break;
+			case 0x0820: // FOR
+			case 0x0830: // NEXT
+			case 0x0821: // WHILE
+			case 0x0831: // WEND
+			case 0x0822: // DO
+			case 0x0832: // WHILE
+				// These are used for detecing the depth of structures.
+				// Change them to stack increase/decrease commands.
+				g_object[pos]=0x27BD0000|(code1&0x0000FFFF); //// addiu       sp,sp,xx
+				break;
+			case 0x2407:                                // addiu       a3,zero,xxxx
+				if (g_object[pos-1]!=0x02E0F809) break; // jalr        ra,s7
+				// call_lib_code(x)
+				switch(code1&0x0000FFFF){
+					case LIB_RESTORE:
+						// Convert label data to pointer if not dynamic
+						code1=g_object[pos-3];
+						code2=g_object[pos-2];
+						if ((code1>>16)!=0x3C02) break; // lui         v0,xxxx
+						if ((code2>>16)!=0x3442) break; // ori         v0,v0,xxxx
+						label=(code1<<16)|(code2&0x0000FFFF);
+						code1=(int)search_label(label);
+						g_label=label;
+						if (!code1) return ERR_LABEL_NF;
+						code2=code1&0x0000FFFF;
+						code1=code1>>16;
+						g_object[pos-3]=0x3C020000|code1;      // lui         v0,xxxx
+						g_object[pos-2]=0x34420000|code2;      // ori         v0,v0,xxxx
+						g_object[pos]=0x24070000|LIB_RESTORE2; // addiu       a3,zero,xxxx
+						break;
+					default:
+						break;
+				}
+				break;
+			default:
+				break;
+		}
+	}
+	return 0;
+}
\ No newline at end of file

--- mips/tags/zoea1.00/float.c	(nonexistent)
+++ mips/tags/zoea1.00/float.c	(revision 148)
@@ -0,0 +1,150 @@
+#include "./compiler.h"
+#include "stdlib.h"
+
+char* get_float_sub(int pr);
+
+char* get_simple_float(void){
+	int i;
+	float f;
+	char* err;
+	char b1,b2,b3;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1=='(') {
+		// (...)
+		// Parenthesis
+		g_srcpos++;
+		next_position();
+		err=get_float_sub(priority(OP_VOID));
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+	} else if (b1=='-') {
+		// Unary '-' operator
+		// Note that unary operators ( + and - ) have higher priority than the other operators
+		g_srcpos++;
+		err=get_simple_float();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3404;                         // ori a0,zero,0x123
+		g_object[g_objpos++]=0x34050000|(OP_SUB&0x0000FFFF); // ori a1,zero,xxxx
+		call_lib_code(LIB_FLOAT);
+	} else {
+		// Main routine of getting float value here
+		if (b1=='+') g_srcpos++; // Ignore unary '+' operator
+		next_position();
+		b1=g_source[g_srcpos];
+		b2=g_source[g_srcpos+1];
+		b3=g_source[g_srcpos+2];
+		if ('0'<=b1 && b1<='9') {
+			f=strtof((const char*)&g_source[g_srcpos],&err);
+			if (&g_source[g_srcpos]==err) return ERR_SYNTAX;
+			g_srcpos=err-g_source;
+			i=((int*)(&f))[0];
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else {
+			if ('A'<=b1 && b1<='Z' && b2=='#' && b3=='(') {
+				// A( - Z(
+				// Dimension
+				g_srcpos++;
+				g_srcpos++;
+				g_srcpos++;
+				return get_dim_value(b1);
+			} else if ('A'<=b1 && b1<='Z' && b2=='#') {
+				// A-Z
+				// Simple value
+				g_srcpos++;
+				g_srcpos++;
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|((b1-'A')*4); // lw v0,xx(s8)
+			} else if ('A'<=b1 && b1<='Z') {
+				// Starts with A-Z
+				// Functions
+				return float_function();
+			} else {
+				return ERR_SYNTAX;
+			}
+		}
+	}
+	// No error 
+	return 0;
+}
+
+char* get_float_sub(int pr){
+	char* err;
+	enum operator op;
+	char b1,b2,b3;
+	int prevpos;
+	// Get a value in $v0.
+	err=get_simple_float();
+	if (err) return err;
+	while(1){
+		// Get the operator in op. If not valid operator, simply return without error.
+		prevpos=g_srcpos;
+		err=get_floatOperator();
+		if (err) return 0;
+		op=g_last_op;
+		// Compair current and previous operators.
+		// If the previous operator has higher priolity, return.
+		if (pr>=priority(op)) {
+			g_srcpos=prevpos;
+			return 0;
+		}
+		// Store $v0 in stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Get next value.
+		err=get_float_sub(priority(op));
+		if (err) return err;
+		// Get value from stack to $a0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FA40000|g_sdepth; // lw a0,xx(sp)
+		g_sdepth-=4;
+		// Calculation. Result will be in $v0.
+		err=calculation_float(op);
+		if (err) return err;
+	}
+}
+
+char* get_float(){
+	// Note that this can be called recursively.
+	// Value may contain function with a parameter of another value.
+	char* err;
+	int prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_objpos++;
+	}
+	err=get_float_sub(priority(OP_VOID));
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+			g_objpos--;
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_FLOAT;
+	return 0;
+}
\ No newline at end of file

--- mips/tags/zoea1.00/videoout.h	(nonexistent)
+++ mips/tags/zoea1.00/videoout.h	(revision 148)
@@ -0,0 +1,108 @@
+#define WIDTH_X	30 // 横方向文字数
+#define WIDTH_Y	27 // 縦方向文字数
+#define ATTROFFSET	(WIDTH_X*WIDTH_Y) // VRAM上のカラーパレット格納位置
+
+#define G_X_RES	256 // 横方向解像度
+#define G_Y_RES	224 // 縦方向解像度
+#define G_H_WORD	(G_X_RES/4) // 1行当りのワード数(16bit単位)
+
+
+// 入力ボタンのポート、ビット定義
+#define KEYPORT PORTB
+#define KEYUP 0x0400
+#define KEYDOWN 0x0080
+#define KEYLEFT 0x0100
+#define KEYRIGHT 0x0200
+#define KEYSTART 0x0800
+#define KEYFIRE 0x4000
+
+extern volatile char drawing;		//　表示期間中は-1
+extern volatile unsigned short drawcount;		//　1画面表示終了ごとに1足す。アプリ側で0にする。
+							// 最低1回は画面表示したことのチェックと、アプリの処理が何画面期間必要かの確認に利用。
+extern unsigned char TVRAM[]; //テキストビデオメモリ
+extern unsigned short *gVRAM; //グラフィックVRAM開始位置のポインタ
+
+extern const unsigned char FontData[]; //フォントパターン定義
+extern unsigned char *cursor;
+extern unsigned char cursorcolor;
+extern unsigned char *fontp;
+
+void start_composite(void); //カラーコンポジット出力開始
+void stop_composite(void); //カラーコンポジット出力停止
+void init_composite(void); //カラーコンポジット出力初期化
+void clearscreen(void); //テキスト画面クリア
+void set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g); //テキストパレット設定
+void set_bgcolor(unsigned char b,unsigned char r,unsigned char g); //バックグランドカラー設定
+void set_graphmode(unsigned char m); //グラフィックモード変更
+void init_graphic(unsigned short *gvram); //グラフィック機能利用準備
+
+void vramscroll(void);
+	//1行スクロール
+void setcursor(unsigned char x,unsigned char y,unsigned char c);
+	//カーソル位置とカラーを設定
+void setcursorcolor(unsigned char c);
+	//カーソル位置そのままでカラー番号をcに設定
+void printchar(unsigned char n);
+	//カーソル位置にテキストコードnを1文字表示し、カーソルを1文字進める
+void printstr(unsigned char *s);
+	//カーソル位置に文字列sを表示
+void printnum(unsigned int n);
+	//カーソル位置に符号なし整数nを10進数表示
+void printnum2(unsigned int n,unsigned char e);
+	//カーソル位置に符号なし整数nをe桁の10進数表示（前の空き桁部分はスペースで埋める）
+void cls(void);
+	//テキスト画面消去し、カーソルを先頭に移動
+void startPCG(unsigned char *p,int a);
+	// RAMフォント（PCG）の利用開始、pがフォント格納場所、aが0以外でシステムフォントをコピー
+void stopPCG(void);
+	// RAMフォント（PCG）の利用停止
+
+void g_clearscreen(void);
+//グラフィック画面クリア
+void g_set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g);
+//グラフィック用カラーパレット設定
+
+void g_pset(int x,int y,unsigned int c);
+// (x,y)の位置にカラーcで点を描画
+
+void g_putbmpmn(int x,int y,char m,char n,const unsigned char bmp[]);
+// 横m*縦nドットのキャラクターを座標x,yに表示
+// unsigned char bmp[m*n]配列に、単純にカラー番号を並べる
+// カラー番号が0の部分は透明色として扱う
+
+void g_clrbmpmn(int x,int y,char m,char n);
+// 縦m*横nドットのキャラクター消去
+// カラー0で塗りつぶし
+
+void g_gline(int x1,int y1,int x2,int y2,unsigned int c);
+// (x1,y1)-(x2,y2)にカラーcで線分を描画
+
+void g_hline(int x1,int x2,int y,unsigned int c);
+// (x1,y)-(x2,y)への水平ラインを高速描画
+
+void g_circle(int x0,int y0,unsigned int r,unsigned int c);
+// (x0,y0)を中心に、半径r、カラーcの円を描画
+
+void g_boxfill(int x1,int y1,int x2,int y2,unsigned int c);
+// (x1,y1),(x2,y2)を対角線とするカラーcで塗られた長方形を描画
+
+void g_circlefill(int x0,int y0,unsigned int r,unsigned int c);
+// (x0,y0)を中心に、半径r、カラーcで塗られた円を描画
+
+void g_putfont(int x,int y,unsigned int c,int bc,unsigned char n);
+//8*8ドットのアルファベットフォント表示
+//座標（x,y)、カラー番号c
+//bc:バックグランドカラー、負数の場合無視
+//n:文字番号
+
+void g_printstr(int x,int y,unsigned int c,int bc,unsigned char *s);
+//座標(x,y)からカラー番号cで文字列sを表示、bc:バックグランドカラー
+
+void g_printnum(int x,int y,unsigned char c,int bc,unsigned int n);
+//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー
+
+void g_printnum2(int x,int y,unsigned char c,int bc,unsigned int n,unsigned char e);
+//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー、e桁で表示
+
+unsigned int g_color(int x,int y);
+//座標(x,y)のVRAM上の現在のパレット番号を返す、画面外は0を返す

--- mips/tags/zoea1.00/error.c	(nonexistent)
+++ mips/tags/zoea1.00/error.c	(revision 148)
@@ -0,0 +1,143 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+
+const char* g_err_str[]={
+	"Syntax error",
+	"Not enough binary space",
+	"Not enough memory",
+	"Divided by zero",
+	"Not yet implemented",
+	"Label or line number not found: ",
+	"Label too long or too short",
+	"String too complexed",
+	"Data not found",
+	"Unknown error",
+	"Music syntax error:'",
+	" found more than twice",
+	"Break",
+	"Unexpected NEXT or RETURN statement",
+	"Cannot assign temporary block",
+	"GOSUB fuction cannot be used after string-handling",
+	"Invalid BREAK statement in line ",
+	"Invalid ELSE/IF statement in line ",
+};
+
+char* resolve_label(int s6){
+	static char str[7];
+	int i,j;
+	if (s6<65536) {
+		// Line number
+		for(i=0;i<5;i++){
+			str[5-i]='0'+rem10_32(s6);
+			s6=div10_32(s6);
+		}
+		str[6]=0x00;
+		for(j=1;j<5;j++){
+			if (str[j]!='0') break;
+		}
+		return (char*)(str+j);
+	} else {
+		// Label
+		s6-=65536;
+		str[6]=0x00;
+		for(i=5;0<=i;i--){
+			if (s6<36) {
+				// First character must be A-Z, corresponding to 1-26 but not 10-35.
+				// See get_label() for the detail.
+				str[i]=s6-1+'A';
+				break;
+			} else {
+				// From second, 0-9 corresponds to 0-9 and A-Z corresponds to 10-35.
+				str[i]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[rem36_32(s6)];
+				s6=div36_32(s6);
+			}
+		}
+		return (char*)(str+i);
+	}
+}
+
+void pre_end_addr(int s6){
+	int i,j;
+	char str[7];
+	if (s6<0) s6=s6&0x7fffffff;
+	g_label=s6;
+	if (s6<65536) {
+		// Line number
+		printstr("\nIn line ");
+	} else {
+		// Label
+		printstr("\nAfter label ");
+	}
+	printstr(resolve_label(s6));
+	asm volatile("la $v0,%0"::"i"(&g_end_addr));
+	asm volatile("lw $v0,0($v0)");
+	asm volatile("nop");
+	asm volatile("jr $v0");
+}
+
+#define end_exec() \
+	asm volatile("addu $a0,$s6,$zero");\
+	asm volatile("j pre_end_addr")
+
+void err_break(void){
+	printstr(ERR_BREAK);
+	end_exec();
+}
+
+void err_data_not_found(void){
+	printstr(ERR_DATA_NF);
+	end_exec();
+}
+
+void err_label_not_found(void){
+	printstr(ERR_LABEL_NF);
+	printstr(resolve_label(g_label));
+	printstr("\n");
+	end_exec();
+}
+
+void err_div_zero(void){
+	printstr(ERR_DIV_0);
+	end_exec();
+}
+
+void err_no_mem(void){
+	printstr(ERR_NE_MEMORY);
+	end_exec();
+}
+
+void err_str_complex(void){
+	printstr(ERR_STR_COMPLEX);
+	end_exec();
+}
+
+void err_unknown(void){
+	printstr(ERR_UNKNOWN);
+	end_exec();
+}
+
+void err_music(char* str){
+	printstr(ERR_MUSIC);
+	printstr(str);
+	printstr("'\n");
+	// Restore s6 from g_s6
+	asm volatile("la $s6,%0"::"i"(&g_s6));
+	asm volatile("lw $s6,0($s6)");
+	end_exec();
+}
+
+void err_unexp_next(void){
+	printstr(ERR_UNEXP_NEXT);
+	end_exec();	
+}
+
+void err_no_block(void){
+	printstr(ERR_NO_BLOCK);
+	end_exec();	
+}

--- mips/tags/zoea1.00/globalvars.c	(nonexistent)
+++ mips/tags/zoea1.00/globalvars.c	(revision 148)
@@ -0,0 +1,71 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#include "compiler.h"
+#include "main.h"
+
+// Contain the valus of $gp and $s6 (GPR of MIPS32)
+int g_gp;
+int g_s6;
+
+// Line data when compiling
+int g_line;
+int g_fileline;
+
+// Contain the address to which return in "END" statement.
+int g_end_addr;
+
+// Following vars are used in value.c and string.c.
+// These define the depth of stack pointer used for
+// handling values and strings.
+int g_sdepth;
+int g_maxsdepth;
+
+// Following var shows what type of variable was defined
+// in compiling the last code.
+enum variable g_lastvar;
+
+// Vars used for handling constant integer
+int g_intconst;
+char g_valueisconst;
+
+// Global vars associated to RAM
+char* g_source;
+int g_srcpos;
+int* g_object;
+int g_objpos;
+int* g_objmax;
+char RAM[RAMSIZE] __attribute__((persistent,address(0xA0000000+PIC32MX_RAMSIZE-PERSISTENT_RAM_SIZE)));
+unsigned int g_ex_data[EXCEPTION_DATA_SIZE/4] __attribute__((persistent,address(0xA0000000+PIC32MX_RAMSIZE-EXCEPTION_DATA_SIZE)));
+
+// Global area for vars A-Z and three temporary string pointers
+int g_var_mem[ALLOC_BLOCK_NUM];
+unsigned short g_var_pointer[ALLOC_BLOCK_NUM];
+unsigned short g_var_size[ALLOC_BLOCK_NUM];
+
+// Flag to use temporary area when compiling
+char g_temp_area_used;
+
+// Heap area
+int* g_heap_mem;
+int g_max_mem;
+
+// Random seed
+int g_rnd_seed;
+
+// Enable/disable Break keys
+char g_disable_break;
+
+// Font data used for PCG
+unsigned char* g_pcg_font;
+
+// Use or do not use graphic
+char g_use_graphic;
+
+// Pointer to graphic RAM
+unsigned short* g_graphic_area;
+

--- mips/tags/zoea1.00/value.c	(nonexistent)
+++ mips/tags/zoea1.00/value.c	(revision 148)
@@ -0,0 +1,271 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+  Public function is only get_value().
+*/
+
+#include "compiler.h"
+
+char* get_value();
+char* get_value_sub(int pr);
+
+char* get_dim_value(char b1){
+	char* err;
+	err=get_value_sub(priority(OP_VOID));
+	if (err) return err;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x00021080;              // sll v0,v0,0x2
+	g_object[g_objpos++]=0x8FC30000|((b1-'A')*4); // lw v1,xx(s8)
+	g_object[g_objpos++]=0x00621821;              // addu v1,v1,v0
+	g_object[g_objpos++]=0x8C620000;              // lw v0,0(v1)
+	next_position();
+	if (g_source[g_srcpos]==','){
+		// 2D, 3D or more
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFFC;          // addiu sp,sp,-4
+		do {
+			g_srcpos++;
+			g_object[g_objpos++]=0xAFA20004;      // sw v0,4(sp)
+			err=get_value_sub(priority(OP_VOID));
+			if (err) return err;
+			check_obj_space(5);
+			g_object[g_objpos++]=0x00021080;      // sll v0,v0,0x2
+			g_object[g_objpos++]=0x8FA30004;      // lw v1,4(sp)
+			g_object[g_objpos++]=0x00621821;      // addu v1,v1,v0
+			g_object[g_objpos++]=0x8C620000;      // lw v0,0(v1)
+		} while (g_source[g_srcpos]==',');
+		g_object[g_objpos++]=0x27BD0004;          // addiu sp,sp,4
+	}
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+char* get_simple_value(void){
+	int i;
+	char* err;
+	char b1,b2;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1=='(') {
+		// (...)
+		// Parenthesis
+		g_srcpos++;
+		next_position();
+		err=get_value_sub(priority(OP_VOID));
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+	} else if (b1=='-') {
+		// Unary '-' operator
+		// Note that unary operators ( + and - ) have higher priority than the other operators
+		g_srcpos++;
+		err=get_simple_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00021023; // subu v0,zero,v0
+		g_intconst=-g_intconst;
+	} else {
+		// Main routine of getting value here
+		if (b1=='+') g_srcpos++; // Ignore unary '+' operator
+		next_position();
+		b1=g_source[g_srcpos];
+		b2=g_source[g_srcpos+1];
+		if (b1=='0' && b2=='X' || b1=='$') {
+			// Starts with '0x' or '$'
+			// Hex number
+			g_srcpos++;
+			if (b1=='0') g_srcpos++;
+			i=0;
+			while(b1=g_source[g_srcpos]) {
+				if ('0'<=b1 && b1<='9') {
+					i*=16;
+					i+=b1-'0';
+				} else if ('A'<=b1 && b1<='F') {
+					i*=16;
+					i+=b1-'A'+0x0A;
+				} else {
+					break;
+				}
+				g_srcpos++;
+			}
+			g_intconst=i;
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else if ('0'<=b1 && b1<='9') {
+			// Starts with 0-9
+			// Decimal number
+			i=0;
+			while(b1=g_source[g_srcpos]) {
+				if ('0'<=b1 && b1<='9') {
+					i*=10;
+					i+=b1-'0';
+				} else {
+					break;
+				}
+				g_srcpos++;
+			}
+			// The next character should not be '.' or 'E'.
+			// Or, it must be recognized as a float value.
+			if (b1=='.' || b1=='E') return ERR_SYNTAX;
+			g_intconst=i;
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else {
+			g_valueisconst=0;
+			if ('A'<=b1 && b1<='Z' && b2=='(') {
+				// A( - Z(
+				// Dimension
+				g_srcpos++;
+				g_srcpos++;
+				return get_dim_value(b1);
+			} else if ('A'<=b1 && b1<='Z' && (b2<'A' || 'Z'<b2) && b2!='#' && b2!='$') {
+				// A-Z
+				// Simple value
+				g_srcpos++;
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|((b1-'A')*4); // lw v0,xx(s8)
+			} else if ('A'<=b1 && b1<='Z') {
+				// Starts with A-Z
+				// Functions
+				return function();
+			} else {
+				return ERR_SYNTAX;
+			}
+		}
+	}
+	// No error 
+	return 0;
+}
+
+char* get_value_sub(int pr){
+	char* err;
+	enum operator op;
+	char b1,b2,b3;
+	int prevpos;
+	// Get a value in $v0.
+	err=get_simple_value();
+	if (err) return err;
+	while(1){
+		// Get the operator in op. If not valid operator, simply return without error.
+		prevpos=g_srcpos;
+		err=get_operator();
+		if (err) return 0;
+		op=g_last_op;
+		// Compair current and previous operators.
+		// If the previous operator has higher priolity, return.
+		if (pr>=priority(op)) {
+			g_srcpos=prevpos;
+			return 0;
+		}
+		// Store $v0 in stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Get next value.
+		err=get_value_sub(priority(op));
+		if (err) return err;
+		// Get value from stack to $v1.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FA30000|g_sdepth; // lw v1,xx(sp)
+		g_sdepth-=4;
+		// Calculation. Result will be in $v0.
+		err=calculation(op);
+		if (err) return err;
+	}
+}
+
+char* get_value(){
+	// This is only the public function.
+	// Note that this can be called recursively.
+	// Value may contain function with a parameter of another value.
+	char* err;
+	int prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_objpos++;
+	}
+	err=get_value_sub(priority(OP_VOID));
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+			g_objpos--;
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_INTEGER;
+	return 0;
+}
+
+char* get_floatOrValue(){
+	char* err;
+	char b;
+	int opos,spos,sdpt;
+	sdpt=g_sdepth;
+	opos=g_objpos;
+	spos=g_srcpos;
+	// First try integer.
+	// Integer value has the higher priolity than float value.
+	err=get_value();
+	b=g_source[g_srcpos];
+	if (err) {
+		// Value is not integer. Let's try float.
+		g_sdepth=sdpt;
+		g_objpos=opos;
+		g_srcpos=spos;
+		return get_float();
+	} else {
+		// Value was recognized as an integer.
+		return 0;
+	}
+}
+
+char* get_stringFloatOrValue(){
+	char* err;
+	int opos,spos;
+	opos=g_objpos;
+	spos=g_srcpos;
+	// First try string, float, then integer.
+	err=get_string();
+	if (err) {
+		g_objpos=opos;
+		g_srcpos=spos;
+		return get_floatOrValue();
+	} else {
+		return 0;
+	}
+}
+

--- mips/tags/zoea1.00/exception.c	(nonexistent)
+++ mips/tags/zoea1.00/exception.c	(revision 148)
@@ -0,0 +1,126 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "main.h"
+#include "compiler.h"
+
+void _general_exception_handler (void){
+	int i;
+	// $v1 is g_ex_data
+	asm volatile("la $v1,%0"::"i"(&g_ex_data[0]));
+	// Prepare proper stack area before SoftReset
+	asm volatile("addiu $sp,$v1,0xfff0");
+	// g_ex_data[2]=$s6
+	asm volatile("sw $s6,8($v1)");
+	// g_ex_data[3]=Cause
+	asm volatile("mfc0 $v0,$13");
+	asm volatile("sw $v0,12($v1)");
+	// g_ex_data[4]=EPC 
+	asm volatile("mfc0 $v0,$14");
+	asm volatile("sw $v0,16($v1)");
+	// Exception occured
+	g_ex_data[0]=1;
+	// g_s6
+	g_ex_data[1]=g_s6;
+	// Clear 2 MLB bits of EPC
+	g_ex_data[4]&=0xfffffffc;
+	// If EPC is within RAM, store data in exception area.
+	if ((int)(&RAM[0])<=g_ex_data[4] && g_ex_data[4] <(int)(&RAM[RAMSIZE])) {
+		// g_ex_data[5] - g_ex_data[12]: assembly
+		for(i=-3;i<=3;i++){
+			g_ex_data[i+8]=((int*)g_ex_data[4])[i];
+		}
+	}
+	// Wait until all buttons are released and reset MachiKania.
+	#ifdef __DEBUG
+		asm volatile("j 0xBFC00000");
+	#else
+		buttonmode();
+		for(i=0;i<100000;i++){
+			if((KEYPORT&(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE))
+				!=(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE)) i=0;
+		}
+		asm volatile("j SoftReset");
+	#endif
+}
+
+void blue_screen(void){
+	int i,j,s6,s6g;
+	unsigned int* opos;
+	if (RCONbits.POR || RCONbits.EXTR) {
+		// After power on or reset. Reset flags and return.
+		RCONbits.POR=0;
+		RCONbits.EXTR=0;
+		for(i=0;i<RAMSIZE;i++){
+			// Reset all RAM area including g_ex_data[]
+			RAM[i]=0;
+		}
+		return;
+	} else if (g_ex_data[0]==0) {
+		// No exception found.
+		return;
+	}
+	// Exception occured before SoftReset().
+	// Prepare data
+	s6=g_ex_data[2];
+	s6g=g_ex_data[1];
+	s6=s6&0x7fffffff;
+	s6g=s6g&0x7fffffff;
+	opos=(int*)g_ex_data[4];
+	//set_bgcolor(255,0,0);
+	printstr("STOP");
+	printstr("\nException at ");
+	printhex32(g_ex_data[4]);
+	printstr("\n      Cause: ");
+	printhex32(g_ex_data[3]);
+	printstr("\n ");
+	switch((g_ex_data[3]>>2)&0x1f){
+		case 0:  printstr("(Interrupt)"); break;
+		case 1:  printstr("(TLB modification)"); break;
+		case 2:  printstr("(TLB load/fetch)"); break;
+		case 3:  printstr("(TLB store)"); break;
+		case 4:  printstr("(Address load/fetch error )"); break;
+		case 5:  printstr("(Address store error)"); break;
+		case 6:  printstr("(Bus fetch error)"); break;
+		case 7:  printstr("(Bus load/store error)"); break;
+		case 8:  printstr("(Syscall)"); break;
+		case 9:  printstr("(Breakpoint)"); break;
+		case 10: printstr("(Reserved instruction)"); break;
+		case 11: printstr("(Coprocessor Unusable)"); break;
+		case 12: printstr("(Integer Overflow)"); break;
+		case 13: printstr("(Trap)"); break;
+		case 23: printstr("(Reference to Watch address)"); break;
+		case 24: printstr("(Machine check)"); break;
+		default: printstr("(Unknown)"); break;
+	}
+	printstr("\n         s6: ");
+	printstr(resolve_label(s6));
+	printstr("\n       g_s6: ");
+	printstr(resolve_label(s6g));
+	printstr("\n");
+	printstr("Reset MachiKania to contine.\n\n");
+	// Show code where the exception happened.
+	for(i=-3;i<=3;i++){
+		printstr("\n ");
+		printhex32((unsigned int)&opos[i]);
+		printstr("  ");
+		if ((unsigned int)&RAM[0]<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<(unsigned int)&RAM[RAMSIZE]) {
+			// Exception in RAM[RAMSIZE] area
+			printhex32(g_ex_data[i+8]);		
+		} else if (   0xA0000000<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<0xA0000000+PIC32MX_RAMSIZE
+			|| 0x9D000000<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<=0x9D000000+PIC32MX_FLASHSIZE) {
+			// Exception in outside RAM[RAMSIZE] or flash area
+			printhex32(opos[i]);
+		} else {
+			printstr("********");
+		}
+	}
+	printstr("\n");
+	while(1) asm("wait");
+}

--- mips/tags/zoea1.00/debug.h	(nonexistent)
+++ mips/tags/zoea1.00/debug.h	(revision 148)
@@ -0,0 +1,25 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#ifdef __DEBUG
+
+// Pseudo reading config setting for debug mode
+extern unsigned int g_DEVCFG1;
+#define DEVCFG1 g_DEVCFG1
+
+// Do not use PS/2 keyboard
+#define ps2init() not_ps2init_but_init_Timer1()
+int not_ps2init_but_init_Timer1();
+
+// Do not use set_graphmode()
+#define set_graphmode(m) (0)
+
+// Do not use asm("wait") but use asm("nop")
+#undef WAIT
+#define WAIT "nop"
+
+#endif // __DEBUG

--- mips/tags/zoea1.00/main.c	(nonexistent)
+++ mips/tags/zoea1.00/main.c	(revision 148)
@@ -0,0 +1,216 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+// main.c
+// MachiKania BASIC System Ver Zoea
+// KM-BASIC 統合開発実行環境 for PIC32MX170F256B / PIC32MX270F256B by K.Tanaka
+
+// 利用システム
+// ps2keyboard.X.a : PS/2キーボード入力システムライブラリ
+// lib_colortext32.a : カラービデオ信号出力システムライブラリ（30×27テキスト版）
+// libsdfsio.a ： SDカードアクセス用ライブラリ
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+#include "editor.h"
+#include "keyinput.h"
+#include "main.h"
+
+//外付けクリスタル with PLL (16倍)
+#pragma config PMDL1WAY = OFF, IOL1WAY = OFF
+#pragma config FPLLIDIV = DIV_1, FPLLMUL = MUL_16, FPLLODIV = DIV_1
+#pragma config FNOSC = PRIPLL, FSOSCEN = OFF, POSCMOD = XT, OSCIOFNC = OFF
+#pragma config FPBDIV = DIV_1, FWDTEN = OFF, JTAGEN = OFF, ICESEL = ICS_PGx1
+#pragma config FCKSM = CSECMD
+
+#define mBMXSetRAMKernProgOffset(offset)	(BMXDKPBA = (offset))
+#define mBMXSetRAMUserDataOffset(offset)	(BMXDUDBA = (offset))
+#define mBMXSetRAMUserProgOffset(offset)	(BMXDUPBA = (offset))
+
+// INIファイル指定キーワード（8文字以内）
+const char InitKeywords[][9]={
+	"106KEY","101KEY","NUMLOCK","CAPSLOCK","SCRLLOCK"
+};
+
+void freadline(char *s,FSFILE *fp){
+// ファイルから1行読み込み、配列sに返す
+// 最大8文字まで。9文字以上の場合無効
+// #または0x20以下のコードを見つけた場合、以降は無視
+// s:9バイト以上の配列
+// fp:ファイルポインタ
+	int n;
+	char c,*p;
+	n=0;
+	p=s;
+	*p=0;
+	while(n<=8){
+		if(FSfread(p,1,1,fp)==0 || *p=='\n'){
+			*p=0;
+			return;
+		}
+		if(*p=='#'){
+			*p=0;
+			break;
+		}
+		if(*p<=' '){
+			if(n>0){
+				*p=0;
+				break;
+			}
+			continue;
+		}
+		p++;
+		n++;
+	}
+	if(n>8) *s=0; //9文字以上の文字列の場合は無効
+	//以降の文字は無視
+	while(FSfread(&c,1,1,fp) && c!='\n') ;
+}
+int searchinittext(char *s){
+// InitKeywords配列の中から文字列sを探し、位置した場合何番目かを返す
+// 見つからなかった場合-1を返す
+	int i;
+	char *p1;
+	const char *p2;
+	for(i=0;i<sizeof(InitKeywords)/sizeof(InitKeywords[0]);i++){
+		p1=s;
+		p2=InitKeywords[i];
+		while(*p1==*p2){
+			if(*p1==0) return i;
+			p1++;
+			p2++;
+		}
+	}
+	return -1;
+}
+void readinifile(void){
+	FSFILE *fp;
+	char inittext[9];
+
+	fp=FSfopen(INIFILE,"r");
+	if(fp==NULL) return;
+	printstr("Initialization File Found\n");
+	lockkey=0; //INIファイルが存在する場合、Lock関連キーはINIファイルに従う
+	while(1){
+		if(FSfeof(fp)) break;
+		freadline(inittext,fp);
+		switch(searchinittext(inittext)){
+			case 0:
+				keytype=0;//日本語キーボード
+				break;
+			case 1:
+				keytype=1;//英語キーボード
+				break;
+			case 2:
+				lockkey|=2;//Num Lock
+				break;
+			case 3:
+				lockkey|=4;//CAPS Lock
+				break;
+			case 4:
+				lockkey|=1;//Scroll Lock
+				break;
+		}
+	}
+	FSfclose(fp);
+}
+
+void printhex8(unsigned char d){
+	printchar("0123456789ABCDEF"[d>>4]);
+	printchar("0123456789ABCDEF"[d&0x0f]);	
+}
+
+void printhex16(unsigned short d){
+	printhex8(d>>8);
+	printhex8(d&0x00ff);
+}
+
+void printhex32(unsigned int d){
+	printhex16(d>>16);
+	printhex16(d&0x0000ffff);
+}
+
+int main(void){
+	char *appname,*s;
+
+	if(DEVCFG1 & 0x8000){
+		// Set Clock switching enabled and reset
+		NVMWriteWord(&DEVCFG1,DEVCFG1 & 0xffff7fff);
+		SoftReset();
+	}
+
+	/* ポートの初期設定 */
+	TRISA = 0x0000; // PORTA全て出力
+	ANSELA = 0x0000; // 全てデジタル
+	TRISB = KEYSTART | KEYFIRE | KEYUP | KEYDOWN | KEYLEFT | KEYRIGHT;// ボタン接続ポート入力設定
+	ANSELB = 0x0000; // 全てデジタル
+	CNPUBSET=KEYSTART | KEYFIRE | KEYUP | KEYDOWN | KEYLEFT | KEYRIGHT;// プルアップ設定
+	ODCB = 0x0300;	//RB8,RB9はオープンドレイン
+
+	// 周辺機能ピン割り当て
+	SDI2R=2; //RPA4:SDI2
+	RPB5R=4; //RPB5:SDO2
+
+	// Make RAM executable. See also "char RAM[RAMSIZE]" in globalvars.c
+	mBMXSetRAMKernProgOffset(PIC32MX_RAMSIZE-RAMSIZE);
+	mBMXSetRAMUserDataOffset(PIC32MX_RAMSIZE);
+	mBMXSetRAMUserProgOffset(PIC32MX_RAMSIZE);
+
+	ps2mode(); //RA1オン（PS/2有効化マクロ）
+	init_composite(); // ビデオメモリクリア、割り込み初期化、カラービデオ出力開始
+	setcursor(0,0,COLOR_NORMALTEXT);
+
+	// Show blue screen if exception before soft reset.
+	blue_screen();
+
+	printstr("MachiKania BASIC System\n");
+	printstr(" Ver "SYSVER1" "SYSVER2" by KENKEN\n");
+	printstr("BASIC Compiler "BASVER"\n");
+	printstr(" by Katsumi\n\n");
+	//SDカードファイルシステム初期化
+	setcursorcolor(COLOR_NORMALTEXT);
+	printstr("Init File System...");
+	// Initialize the File System
+	if(FSInit()==FALSE){ //ファイルシステム初期化
+		//エラーの場合停止
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("\nFile System Error\n");
+		printstr("Insert Correct Card\n");
+		printstr("And Reset\n");
+		while(1) asm("wait");
+	}
+	printstr("OK\n");
+	lockkey=2; // NumLockキーオン
+	keytype=0; // 日本語キーボード
+	readinifile(); //INIファイル読み込み
+	printstr("Init PS/2...");
+	if(ps2init()){ //PS/2初期化
+		//キーボードが見つからない場合
+		printstr("Keyboard Not Found\n");
+	}
+	else printstr("OK\n");
+
+	wait60thsec(60); //1秒待ち
+
+	// 実行中HEXファイル名がHEXFILEと一致した場合はエディタ起動
+	appname=(char*)FILENAME_FLASH_ADDRESS;
+	s=HEXFILE;
+	while(*s++==*appname++) if(*s==0) texteditor(); //テキストエディター呼び出し
+
+	// 実行中HEXファイル名の「.HEX」を「.BAS」に置き換えてBASファイルを実行
+	appname=(char*)FILENAME_FLASH_ADDRESS;
+	s=tempfile;
+	while(*appname!='.') *s++=*appname++;
+	appname=".BAS";
+	while(*appname!=0) *s++=*appname++;
+	*s=0;
+	// buttonmode(); //ボタン有効化
+	g_disable_break=1; // Breakキー無効化
+	runbasic(tempfile,0);
+	while(1) asm(WAIT);
+}

--- mips/tags/zoea1.00/api.h	(nonexistent)
+++ mips/tags/zoea1.00/api.h	(revision 148)
@@ -0,0 +1,38 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#ifndef BOOL
+	typedef enum _BOOL { FALSE = 0, TRUE } BOOL; 
+#endif
+
+#ifndef BYTE
+	#define BYTE unsigned char
+#endif
+
+#ifndef WORD
+	#define WORD unsigned short
+#endif
+
+#ifndef DWORD
+	#define DWORD unsigned long
+#endif
+
+#ifndef UINT16
+	#define UINT16 unsigned short
+#endif
+
+#ifndef size_t
+	#define size_t unsigned int
+#endif
+
+// Used for asm("wait")
+#define WAIT "wait"
+
+#include "videoout.h"
+#include "SDFSIO.h"
+#include "ps2keyboard.h"
+#include "debug.h"

--- mips/tags/zoea1.00/operator.c	(nonexistent)
+++ mips/tags/zoea1.00/operator.c	(revision 148)
@@ -0,0 +1,275 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+
+/*
+Operators: (upper ones have higher priority
+()
+* / %
++ -
+<< >>
+< <= > >=
+= !=
+XOR
+AND
+OR
+*/
+
+
+const unsigned char g_priority[]={
+	0, // OP_VOID
+	1, // OP_OR
+	2, // OP_AND
+	3, // OP_XOR
+	4,4, // OP_EQ, OP_NEQ
+	5,5,5,5, // OP_LT, OP_LTE, OP_MT, OP_MTE
+	6,6, // OP_SHL, OP_SHR
+	7,7, // OP_ADD, OP_SUB
+	8,8,8 // OP_MUL, OP_DIV, OP_REM
+};
+
+enum operator g_last_op;
+
+char* get_operator(void){
+	char b1,b2,b3;
+	next_position();
+	b1=g_source[g_srcpos];
+	b2=g_source[g_srcpos+1];
+	b3=g_source[g_srcpos+2];
+	switch(b1){
+		case '%': g_last_op=OP_REM; break;
+		case '/': g_last_op=OP_DIV; break;
+		case '*': g_last_op=OP_MUL; break;
+		case '-': g_last_op=OP_SUB; break;
+		case '+': g_last_op=OP_ADD; break;
+		case '>':
+			if (b2=='>') {
+				g_srcpos++;
+				g_last_op=OP_SHR;
+			} else if (b2=='=') {
+				g_srcpos++;
+				g_last_op=OP_MTE;
+			} else {
+				g_last_op=OP_MT;
+			}
+			break;
+		case '<':
+			if (b2=='<') {
+				g_srcpos++;
+				g_last_op=OP_SHL;
+			} else if (b2=='=') {
+				g_srcpos++;
+				g_last_op=OP_LTE;
+			} else {
+				g_last_op=OP_LT;
+			}
+			break;
+		case '!':
+			if (b2!='=') return ERR_SYNTAX;
+			g_srcpos++;
+			g_last_op=OP_NEQ;
+			break;
+		case '=':
+			if (b2=='=') g_srcpos++;
+			g_last_op=OP_EQ;
+			break;
+		case 'X':
+			if (b2!='O') return ERR_SYNTAX;
+			if (b3!='R') return ERR_SYNTAX;
+			g_srcpos++;
+			g_srcpos++;
+			g_last_op=OP_XOR;
+			break;
+		case 'O':
+			if (b2!='R') return ERR_SYNTAX;
+			g_srcpos++;
+			g_last_op=OP_OR;
+			break;
+		case 'A':
+			if (b2!='N') return ERR_SYNTAX;
+			if (b3!='D') return ERR_SYNTAX;
+			g_srcpos++;
+			g_srcpos++;
+			g_last_op=OP_AND;
+			break;
+		default:
+			return ERR_SYNTAX;
+	}
+	g_srcpos++;
+	return 0;
+}
+
+char* get_floatOperator(void){
+	char* err;
+	int spos;
+	next_position();
+	spos=g_srcpos;
+	err=get_operator();
+	if (err) return err;
+	switch(g_last_op){
+		// Following operators cannot be used for float values.
+		case OP_XOR:
+		case OP_REM:
+		case OP_SHR:
+		case OP_SHL:
+			g_srcpos=spos;
+			return ERR_SYNTAX;
+		default:
+			return 0;
+	}
+}
+
+char* calculation(enum operator op){
+	// $v0 = $v1 <op> $v0;
+	switch(op){
+		case OP_OR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621025; // or          v0,v1,v0
+			break;
+		case OP_AND:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621024; // and         v0,v1,v0
+			break;
+		case OP_XOR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			break;
+		case OP_EQ:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			g_object[g_objpos++]=0x2C420001; // sltiu       v0,v0,1
+			break;
+		case OP_NEQ:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			g_object[g_objpos++]=0x0002102B; // sltu        v0,zero,v0
+			break;
+		case OP_LT:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x0062102A; // slt         v0,v1,v0
+			break;
+		case OP_LTE:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x0043102A; // slt         v0,v0,v1
+			g_object[g_objpos++]=0x38420001; // xori        v0,v0,0x1
+			break;
+		case OP_MT:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x0043102A; // slt         v0,v0,v1
+			break;
+		case OP_MTE:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x0062102A; // slt         v0,v1,v0
+			g_object[g_objpos++]=0x38420001; // xori        v0,v0,0x1
+			break;
+		case OP_SHR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00431006; // srlv        v0,v1,v0
+			break;
+		case OP_SHL:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00431004; // sllv        v0,v1,v0
+			break;
+		case OP_ADD:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621021; // addu        v0,v1,v0
+			break;
+		case OP_SUB:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621023; // subu        v0,v1,v0
+			break;
+		case OP_MUL:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x70621002; // mul         v0,v1,v0
+			break;
+		case OP_DIV:
+			// Note that intterupt functions do not use mflo and mfhi.
+			// Probably using div does not cause delay of interrupt.
+			check_obj_space(5);
+			g_object[g_objpos++]=0x14400003;                                        // bne         v0,zero,label
+			g_object[g_objpos++]=0x0062001A;                                        // div         v1,v0
+			call_lib_code(LIB_DIV0); // 2 words
+ 			                                                                        // label:
+			g_object[g_objpos++]=0x00001012;                                        // mflo        v0
+			break;
+		case OP_REM:
+			check_obj_space(5);
+			g_object[g_objpos++]=0x14400003;                                        // bne         v0,zero,label
+			g_object[g_objpos++]=0x0062001A;                                        // div         v1,v0
+			call_lib_code(LIB_DIV0); // 2 words
+ 			                                                                        // label:
+			g_object[g_objpos++]=0x00001010;                                        // mfhi        v0
+			break;
+		default:
+			return ERR_SYNTAX;
+	}
+	return 0;
+}
+
+char* calculation_float(enum operator op){
+	// $v0 = $a0 <op> $v0;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34050000|(op&0x0000FFFF); // ori a1,zero,xxxx
+	// All the calculations will be done in library code, lib_float function (see below).
+	call_lib_code(LIB_FLOAT);
+	return 0;
+}
+
+int lib_float(int ia0,int iv0, enum operator a1){
+	// This function was called from _call_library().
+	// Variable types must be all int.
+	// Casting cannot be used.
+	// Instead, by using pointer, put as int value, get as float value, 
+	// calculate, put as float value, then get as int value for returning.
+	volatile float a0,v0;
+	((int*)(&a0))[0]=ia0;
+	((int*)(&v0))[0]=iv0;
+	switch(a1){
+		case OP_EQ:
+			v0= a0==v0?1:0;
+			break;
+		case OP_NEQ:
+			v0= a0!=v0?1:0;
+			break;
+		case OP_LT:
+			v0= a0<v0?1:0;
+			break;
+		case OP_LTE:
+			v0= a0<=v0?1:0;
+			break;
+		case OP_MT:
+			v0= a0>v0?1:0;
+			break;
+		case OP_MTE:
+			v0= a0>=v0?1:0;
+			break;
+		case OP_ADD:
+			v0= a0+v0;
+			break;
+		case OP_SUB:
+			v0= a0-v0;
+			break;
+		case OP_MUL:
+			v0= a0*v0;
+			break;
+		case OP_DIV:
+			if (v0==0) err_div_zero();
+			v0= a0/v0;
+			break;
+		case OP_OR:
+			v0= a0||v0?1:0;
+			break;
+		case OP_AND:
+			v0= a0&&v0?1:0;
+			break;
+		default:
+			err_unknown();
+			return 0;
+	}
+	return ((int*)(&v0))[0];
+}; 
\ No newline at end of file

--- mips/tags/zoea1.00/memory.c	(nonexistent)
+++ mips/tags/zoea1.00/memory.c	(revision 148)
@@ -0,0 +1,175 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include "compiler.h"
+
+/*
+	ALLOC_VAR_NUM:    # of variables used for allocation of memory (string/dimension).
+	                  0 is for A, 1 is for B, ... , and 25 is for Z.
+	                  This number also includes temporary area used for string construction etc.
+	                  Temporary area is cleared every line of BASIC code in alloc_memory().
+	ALLOC_BLOCK_NUM:  # of blocks that can be used for memory allocation.
+	                  This # also includes the ones for ALLOC_VAR_NUM.
+	                  After ALLOC_VAR_NUM area, dedicated memory area and permanent area follows.
+	                  Currently, only PCG is used for permanent pourpose.
+                      10 permanant blocks can be used.
+	                  Therefore, ALLOC_VAR_NUM+11 == ALLOC_BLOCK_NUM
+	ALLOC_PERM_BLOCK: Start # of permanent blocks.
+                      The blocks after this number is permanently stored.
+                      Therefore, it must be released when it's not used any more.
+*/
+
+void set_free_area(void* begin, void* end){
+	int i;
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_size[i]=0;
+	}
+	g_heap_mem=(int*)begin;
+	g_max_mem=(int)((end-begin)/4);
+}
+
+void* calloc_memory(int size, int var_num){
+	int i;
+	void* ret;
+	// Allocate memory
+	ret=alloc_memory(size,var_num);
+	// Fill zero in allocated memory
+	for(i=0;i<size;i++){
+		((int*)ret)[i]=0;
+	}
+	// return pointer to allocated memory
+	return ret;
+}
+void* alloc_memory(int size, int var_num){
+	// Remove temporary blocks once a line.
+	asm volatile("nop");
+	asm volatile("bltz $s6,_alloc_memory_main"); // Skip if $s6<0
+	// Following code will be activated after setting $s6 register
+	// every line and after label statement.
+	asm volatile("lui $v0,0x8000");
+	asm volatile("or $s6,$v0,$s6");              // $s6=0x80000000|$s6;
+	// Remove all temporary blocks
+	// Note that g_var_size is short integer.
+	// Note that ALLOC_VAR_NUM is used here (but not ALLOC_BLOC_NUM)
+	//	for(i=26;i<ALLOC_VAR_NUM;i++)g_var_size[i]=0;
+	asm volatile("addiu $v0,$zero,%0"::"n"((ALLOC_VAR_NUM-26)/2)); // $v0=(ALLOC_VAR_NUM-26)/2
+	asm volatile("la $v1,%0"::"i"(&g_var_size[0]));                // $v1=g_var_size
+	asm volatile("loop:");
+	asm volatile("sw $zero,(26*2)($v1)");                          // $v1[26]=0, $v1[27]=0
+	asm volatile("addiu $v0,$v0,-1");                              // $v0--
+	asm volatile("addiu $v1,$v1,4");                               // $v1+=2
+	asm volatile("bne $v0,$zero,loop");                            // loop if 0<$v0
+	asm volatile("b _alloc_memory_main");
+}
+void* _alloc_memory_main(int size, int var_num){
+	int i,j,candidate;
+	// Assign temp var number
+	if (var_num<0) {
+		// Use ALLOC_VAR_NUM here but not ALLOC_BLOCK_NUM
+		for(i=26;i<ALLOC_VAR_NUM;i++){
+			if (g_var_size[i]==0) {
+				var_num=i;
+				break;
+			}
+		}
+		if (var_num<0) {
+			err_str_complex();
+			return 0;
+		}
+	}
+	// Clear var to be assigned.
+	g_var_size[var_num]=0;
+	g_var_pointer[var_num]=0;
+	while(1){
+		// Try the block after last block
+		candidate=0;
+		for(i=0;i<ALLOC_BLOCK_NUM;i++){
+			if (g_var_size[i]==0) continue;
+			if (candidate<=g_var_pointer[i]) {
+				candidate=g_var_pointer[i]+g_var_size[i];
+			}
+		}
+		if (candidate+size<=g_max_mem) break;
+		// Check between blocks
+		// Note that there is at least one block with zero pointer and zero size (see above).
+		for(i=0;i<ALLOC_BLOCK_NUM;i++){
+			// Candidate is after this block.
+			candidate=g_var_pointer[i]+g_var_size[i];
+			// Check if there is an overlap.
+			for(j=0;j<ALLOC_BLOCK_NUM;j++){
+				if (g_var_size[j]==0) continue;
+				if (candidate+size<=g_var_pointer[j]) continue;
+				if (g_var_pointer[j]+g_var_size[j]<=candidate) continue;
+				// This block overlaps with the candidate
+				candidate=-1;
+				break;
+			}
+			if (0<=candidate && candidate+size<=g_max_mem) {
+				// Available block found
+				break;
+			} else {
+				candidate=-1;
+			}
+		}
+		if (0<=candidate) break;
+		// New memory block cannot be allocated.
+		err_no_mem();
+		return 0;
+	}
+	// Available block found.
+	g_var_pointer[var_num]=candidate;
+	g_var_size[var_num]=size;
+	g_var_mem[var_num]=(int)(&(g_heap_mem[candidate]));
+	return (void*)g_var_mem[var_num];
+}
+
+void free_temp_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			g_var_size[i]=0;
+			break;
+		}
+	}
+}
+
+void move_to_perm_block(int var_num){
+	int i;
+	// Find available permanent block
+	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_size[i]==0) break;
+	}
+	if (ALLOC_BLOCK_NUM<=i) err_no_block(); // Not found
+	// Available block found.
+	// Copy value from variable.
+	g_var_size[i]=g_var_size[var_num];
+	g_var_pointer[i]=g_var_pointer[var_num];
+	g_var_mem[i]=g_var_mem[var_num];
+	// Clear variable
+	g_var_size[var_num]=0;
+	g_var_mem[var_num]=0;
+}
+
+void move_from_perm_block(int var_num){
+	int i,pointer;
+	pointer=(int)g_var_mem[var_num]-(int)g_heap_mem;
+	pointer>>=2;
+	// Find stored block
+	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++){
+		if (0<g_var_size[i] && g_var_pointer[i]==pointer) break;
+	}
+	if (ALLOC_BLOCK_NUM<=i) err_unknown(); // Not found
+	// Stored block found.
+	// Replace pointer
+	g_var_size[var_num]=g_var_size[i];
+	g_var_pointer[var_num]=g_var_pointer[i];
+	// Clear block
+	g_var_size[i]=0;
+}
\ No newline at end of file

--- mips/tags/zoea1.00/keyinput.c	(nonexistent)
+++ mips/tags/zoea1.00/keyinput.c	(revision 148)
@@ -0,0 +1,199 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+// キー入力、カーソル表示関連機能 by K.Tanaka
+// PS/2キーボード入力システム、カラーテキスト出力システム利用
+
+#include "videoout.h"
+#include "ps2keyboard.h"
+#include "keyinput.h"
+
+unsigned char lineinputbuf[256]; //lineinput関数用一時バッファ
+unsigned char blinkchar,blinkcolor;
+int blinktimer;
+int insertmode; //挿入モード：1、上書きモード：0
+
+void getcursorchar(){
+// カーソル点滅用に元の文字コードを退避
+	blinkchar=*cursor;
+	blinkcolor=*(cursor+ATTROFFSET);
+}
+void resetcursorchar(){
+// カーソルを元の文字に戻す
+	*cursor=blinkchar;
+	*(cursor+ATTROFFSET)=blinkcolor;
+}
+void blinkcursorchar(){
+// 定期的に呼び出すことでカーソルを点滅表示させる
+// BLINKTIMEで点滅間隔を設定
+// 事前にgetcursorchar()を呼び出しておく
+	blinktimer++;
+	if(blinktimer>=BLINKTIME*2) blinktimer=0;
+	if(blinktimer<BLINKTIME){
+		if(insertmode) *cursor=CURSORCHAR;
+		else *cursor=CURSORCHAR2;
+		*(cursor+ATTROFFSET)=CURSORCOLOR;
+	}
+	else{
+		*cursor=blinkchar;
+		*(cursor+ATTROFFSET)=blinkcolor;
+	}
+}
+
+unsigned char inputchar(void){
+// キーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+	unsigned char k;
+	unsigned short d;
+	d=drawcount;
+	while(1){
+		while(d==drawcount) asm("wait"); //60分の1秒ウェイト
+		d=drawcount;
+		k=ps2readkey();  //キーバッファから読み込み、k1:通常文字入力の場合ASCIIコード
+		if(vkey) return k;
+	}
+}
+
+unsigned char cursorinputchar(void){
+// カーソル表示しながらキーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+	unsigned char k;
+	unsigned short d;
+	getcursorchar(); //カーソル位置の文字を退避（カーソル点滅用）
+	d=drawcount;
+	while(1){
+		while(d==drawcount) asm("wait"); //60分の1秒ウェイト
+		d=drawcount;
+		blinkcursorchar(); //カーソル点滅させる
+		k=ps2readkey();  //キーバッファから読み込み、k1:通常文字入力の場合ASCIIコード
+		if(vkey) break;  //キーが押された場合ループから抜ける
+	}
+	resetcursorchar(); //カーソルを元の文字表示に戻す
+	return k;
+}
+
+unsigned char printinputchar(void){
+// カーソル表示しながらキーボードから通常文字キー入力待ちし、入力された文字を表示
+// 戻り値 入力された文字のASCIIコード、グローバル変数vkeyに最後に押されたキーの仮想キーコード
+	unsigned char k;
+	while(1){
+		k=cursorinputchar();
+		if(k) break;
+	}
+	printchar(k);
+	return k;
+}
+
+int lineinput(char *s,int n){
+// キー入力して文字列配列sに格納
+// sに初期文字列を入れておくと最初に表示して文字列の最後にカーソル移動する
+// 初期文字列を使用しない場合は*s=0としておく
+// カーソル位置はsetcursor関数で指定しておく
+// 最大文字数n、最後に0を格納するのでn+1バイトの領域必要、ただしnの最大値は255
+// 戻り値　Enterで終了した場合0、ESCで終了時は-1（sは壊さない）
+//
+	unsigned char *ps,*pd,*pc;
+	unsigned char k1,k2;
+	int i;
+
+	if(n>255) return -1;
+	ps=s;
+	pd=lineinputbuf;
+	i=0;
+	//初期文字列をlineinputbufにコピーし、文字数をiに入れる
+	while(*ps!=0 && i<n){
+		*pd++=*ps++;
+		i++;
+	}
+	*pd=0;//バッファ内の文字列最後に0
+	pc=pd;//現在の文字入力位置ポインタ（最後尾）
+	if(i>0) printstr(lineinputbuf); //初期文字列表示
+	while(1){
+		k1=cursorinputchar(); //カーソル表示しながら1キー入力待ち
+		k2=(unsigned char)vkey; //k2:仮想キーコード
+		if(k1){
+			//通常文字の場合
+			if(insertmode || *pc==0){
+				//挿入モードまたは最後尾の場合
+				if(i==n) continue; //入力文字数最大値の場合無視
+				for(pd=lineinputbuf+i;pd>=pc;pd--) *(pd+1)=*pd; //1文字分挿入
+				i++;
+			}
+			*pc=k1; //入力文字を追加
+			printstr(pc); //入力文字以降を表示
+			pc++;
+			for(ps=lineinputbuf+i;ps>pc;ps--) cursor--; //カーソル位置戻し
+		}
+		else switch(k2){
+			//制御文字の場合
+			case VK_LEFT:
+			case VK_NUMPAD4:
+				//左矢印キー
+				if(pc>lineinputbuf){
+					pc--;
+					cursor--;
+				}
+				break;
+			case VK_RIGHT:
+			case VK_NUMPAD6:
+				//右矢印キー
+				if(*pc!=0){
+					pc++;
+					cursor++;
+				}
+				break;
+			case VK_RETURN: //Enterキー
+			case VK_SEPARATOR: //テンキーのEnter
+				//入力用バッファから呼び出し元のバッファにコピーして終了
+				printchar('\n');
+				ps=lineinputbuf;
+				pd=s;
+				while(*ps!=0) *pd++=*ps++;
+				*pd=0;
+				return 0;
+			case VK_HOME:
+			case VK_NUMPAD7:
+				//Homeキー、文字列先頭にカーソル移動
+				while(pc>lineinputbuf){
+					pc--;
+					cursor--;
+				}
+				break;
+			case VK_END:
+			case VK_NUMPAD1:
+				//Endキー、文字列最後尾にカーソル移動
+				while(*pc!=0){
+					pc++;
+					cursor++;
+				}
+				break;
+			case VK_BACK:
+				//Back Spaceキー、1文字左に移動しDelete処理
+				if(pc==lineinputbuf) break;//カーソルが先頭の場合、無視
+				pc--;
+				cursor--;
+			case VK_DELETE:
+			case VK_DECIMAL:
+				//Deleteキー、カーソル位置の1文字削除
+				if(*pc==0) break;//カーソルが最後尾の場合、無視
+				for(pd=pc;*(pd+1)!=0;pd++) *pd=*(pd+1);
+				*pd=0;
+				i--;
+				printstr(pc);
+				printchar(0);//NULL文字表示
+				for(ps=lineinputbuf+i+1;ps>pc;ps--) cursor--;
+				break;
+			case VK_INSERT:
+			case VK_NUMPAD0:
+				//Insertキー、挿入モードトグル動作
+				insertmode^=1;
+				break;
+			case VK_ESCAPE:
+			case VK_CANCEL:
+				//ESCキーまたはCTRL+Breakキー、-1で終了
+				return -1;
+		}
+	}
+}

--- mips/tags/zoea1.00/ps2keyboard.h	(nonexistent)
+++ mips/tags/zoea1.00/ps2keyboard.h	(revision 148)
@@ -0,0 +1,174 @@
+#define CHK_SHIFT 0x01
+#define CHK_CTRL 0x02
+#define CHK_ALT 0x04
+#define CHK_WIN 0x08
+#define CHK_SCRLK 0x10
+#define CHK_NUMLK 0x20
+#define CHK_CAPSLK 0x40
+#define CHK_SHIFT_L 0x01
+#define CHK_SHIFT_R 0x02
+#define CHK_CTRL_L 0x04
+#define CHK_CTRL_R 0x08
+#define CHK_ALT_L 0x10
+#define CHK_ALT_R 0x20
+#define CHK_WIN_L 0x40
+#define CHK_WIN_R 0x80
+#define CHK_SCRLK_A 0x100
+#define CHK_NUMLK_A 0x200
+#define CHK_CAPSLK_A 0x400
+
+#define VK_LBUTTON 0x01
+#define VK_RBUTTON 0x02
+#define VK_CANCEL 0x03
+#define VK_MBUTTON 0x04
+#define VK_XBUTTON1 0x05
+#define VK_XBUTTON2 0x06
+#define VK_BACK 0x08
+#define VK_TAB 0x09
+#define VK_CLEAR 0x0C
+#define VK_RETURN 0x0D
+#define VK_SHIFT 0x10
+#define VK_CONTROL 0x11
+#define VK_MENU 0x12
+#define VK_PAUSE 0x13
+#define VK_CAPITAL 0x14
+#define VK_KANA 0x15
+#define VK_HANGUEL 0x15
+#define VK_HANGUL 0x15
+#define VK_JUNJA 0x17
+#define VK_FINAL 0x18
+#define VK_HANJA 0x19
+#define VK_KANJI 0x19
+#define VK_ESCAPE 0x1B
+#define VK_CONVERT 0x1C
+#define VK_NONCONVERT 0x1D
+#define VK_ACCEPT 0x1E
+#define VK_MODECHANGE 0x1F
+#define VK_SPACE 0x20
+#define VK_PRIOR 0x21
+#define VK_NEXT 0x22
+#define VK_END 0x23
+#define VK_HOME 0x24
+#define VK_LEFT 0x25
+#define VK_UP 0x26
+#define VK_RIGHT 0x27
+#define VK_DOWN 0x28
+#define VK_SELECT 0x29
+#define VK_PRINT 0x2A
+#define VK_EXECUTE 0x2B
+#define VK_SNAPSHOT 0x2C
+#define VK_INSERT 0x2D
+#define VK_DELETE 0x2E
+#define VK_HELP 0x2F
+#define VK_LWIN 0x5B
+#define VK_RWIN 0x5C
+#define VK_APPS 0x5D
+#define VK_SLEEP 0x5F
+#define VK_NUMPAD0 0x60
+#define VK_NUMPAD1 0x61
+#define VK_NUMPAD2 0x62
+#define VK_NUMPAD3 0x63
+#define VK_NUMPAD4 0x64
+#define VK_NUMPAD5 0x65
+#define VK_NUMPAD6 0x66
+#define VK_NUMPAD7 0x67
+#define VK_NUMPAD8 0x68
+#define VK_NUMPAD9 0x69
+#define VK_MULTIPLY 0x6A
+#define VK_ADD 0x6B
+#define VK_SEPARATOR 0x6C
+#define VK_SUBTRACT 0x6D
+#define VK_DECIMAL 0x6E
+#define VK_DIVIDE 0x6F
+#define VK_F1 0x70
+#define VK_F2 0x71
+#define VK_F3 0x72
+#define VK_F4 0x73
+#define VK_F5 0x74
+#define VK_F6 0x75
+#define VK_F7 0x76
+#define VK_F8 0x77
+#define VK_F9 0x78
+#define VK_F10 0x79
+#define VK_F11 0x7A
+#define VK_F12 0x7B
+#define VK_F13 0x7C
+#define VK_F14 0x7D
+#define VK_F15 0x7E
+#define VK_F16 0x7F
+#define VK_F17 0x80
+#define VK_F18 0x81
+#define VK_F19 0x82
+#define VK_F20 0x83
+#define VK_F21 0x84
+#define VK_F22 0x85
+#define VK_F23 0x86
+#define VK_F24 0x87
+#define VK_NUMLOCK 0x90
+#define VK_SCROLL 0x91
+#define VK_LSHIFT 0xA0
+#define VK_RSHIFT 0xA1
+#define VK_LCONTROL 0xA2
+#define VK_RCONTROL 0xA3
+#define VK_LMENU 0xA4
+#define VK_RMENU 0xA5
+#define VK_BROWSER_BACK 0xA6
+#define VK_BROWSER_FORWARD 0xA7
+#define VK_BROWSER_REFRESH 0xA8
+#define VK_BROWSER_STOP 0xA9
+#define VK_BROWSER_SEARCH 0xAA
+#define VK_BROWSER_FAVORITES 0xAB
+#define VK_BROWSER_HOME 0xAC
+#define VK_VOLUME_MUTE 0xAD
+#define VK_VOLUME_DOWN 0xAE
+#define VK_VOLUME_UP 0xAF
+#define VK_MEDIA_NEXT_TRACK 0xB0
+#define VK_MEDIA_PREV_TRACK 0xB1
+#define VK_MEDIA_STOP 0xB2
+#define VK_MEDIA_PLAY_PAUSE 0xB3
+#define VK_LAUNCH_MAIL 0xB4
+#define VK_LAUNCH_MEDIA_SELECT 0xB5
+#define VK_LAUNCH_APP1 0xB6
+#define VK_LAUNCH_APP2 0xB7
+#define VK_OEM_1 0xBA
+#define VK_OEM_PLUS 0xBB
+#define VK_OEM_COMMA 0xBC
+#define VK_OEM_MINUS 0xBD
+#define VK_OEM_PERIOD 0xBE
+#define VK_OEM_2 0xBF
+#define VK_OEM_3 0xC0
+#define VK_OEM_4 0xDB
+#define VK_OEM_5 0xDC
+#define VK_OEM_6 0xDD
+#define VK_OEM_7 0xDE
+#define VK_OEM_8 0xDF
+#define VK_OEM_102 0xE2
+#define VK_PROCESSKEY 0xE5
+#define VK_PACKE 0xE7
+#define VK_ATTN 0xF6
+#define VK_CRSEL 0xF7
+#define VK_EXSEL 0xF8
+#define VK_EREOF 0xF9
+#define VK_PLAY 0xFA
+#define VK_ZOOM 0xFB
+#define VK_NONAME 0xFC
+#define VK_PA1 0xFD
+#define VK_OEM_CLEAR 0xFE
+
+extern volatile unsigned char ps2keystatus[256]; // 仮想コードに相当するキーの状態（Onの時1）
+extern volatile unsigned short vkey; //仮想キーコード
+extern unsigned char lockkey; // 初期化時にLockキーの状態指定。下位3ビットが<CAPSLK><NUMLK><SCRLK>
+extern unsigned char keytype; // キーボードの種類。0：日本語109キー、1：英語104キー
+
+int ps2init(); // PS/2ライブラリ関連初期化。正常終了0、エラーで-1を返す
+unsigned char shiftkeys(); // SHIFT関連キーの押下状態を返す
+unsigned char ps2readkey();
+// 入力された1つのキーのキーコードをグローバル変数vkeyに格納（押されていなければ0を返す）
+// 下位8ビット：キーコード
+// 上位8ビット：シフト状態（押下：1）、上位から<0><CAPSLK><NUMLK><SCRLK><Win><ALT><CTRL><SHIFT>
+// 英数・記号文字の場合、戻り値としてASCIIコード（それ以外は0を返す）
+
+// PIC32MX1xx/2xx版のキーボードとボタンの排他利用システムで使用する関数、マクロ
+void ps2mode(); // PS/2を有効にする
+void buttonmode(); // ボタンを有効にする
+#define inPS2MODE() ((LATA&2)>>1) // モード確認用マクロ。PS/2モードの場合1、ボタンモードの場合0を返す

--- mips/tags/zoea1.00/keyinput.h	(nonexistent)
+++ mips/tags/zoea1.00/keyinput.h	(revision 148)
@@ -0,0 +1,45 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+
+#define BLINKTIME 15
+#define CURSORCHAR 0x87
+#define CURSORCHAR2 0x80
+#define CURSORCOLOR 7
+
+void getcursorchar();
+// カーソル点滅用に元の文字コードを退避
+
+void resetcursorchar();
+// カーソルを元の文字に戻す
+
+void blinkcursorchar();
+// 定期的に呼び出すことでカーソルを点滅表示させる
+// BLINKTIMEで点滅間隔を設定
+// 事前にgetcursorchar()を呼び出しておく
+
+int lineinput(char *s,int n);
+// キー入力して文字列配列sに格納
+// sに初期文字列を入れておくと最初に表示して文字列の最後にカーソル移動する
+// 初期文字列を使用しない場合は*s=0としておく
+// カーソル位置はsetcursor関数で指定しておく
+// 最大文字数n、最後に0を格納するのでn+1バイトの領域必要、ただしnの最大値は255
+// 戻り値　Enterで終了した場合0、ESCで終了時は-1（sは壊さない）
+
+unsigned char inputchar(void);
+// キーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+
+unsigned char printinputchar(void);
+// カーソル表示しながらキーボードから通常文字キー入力待ちし、入力された文字を表示
+// 戻り値 入力された文字のASCIIコード、グローバル変数vkeyに最後に押されたキーの仮想キーコード
+
+unsigned char cursorinputchar(void);
+// カーソル表示しながらキーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+
+extern unsigned char blinkchar,blinkcolor;
+extern int blinktimer;
+extern int insertmode; //挿入モード：1、上書きモード：0

--- mips/tags/zoea1.00/SDFSIO.h	(nonexistent)
+++ mips/tags/zoea1.00/SDFSIO.h	(revision 148)
@@ -0,0 +1,2344 @@
+/******************************************************************************
+ *
+ *                Microchip Memory Disk Drive File System
+ *
+ ******************************************************************************
+ * FileName:        FSIO.h
+ * Dependencies:    GenericTypeDefs.h
+ *                  FSconfig.h
+ *                  FSDefs.h
+ *                  stddef.h
+ * Processor:       PIC18/PIC24/dsPIC30/dsPIC33/PIC32
+ * Compiler:        C18/C30/C32
+ * Company:         Microchip Technology, Inc.
+ * Version:         1.3.0
+ *
+ * Software License Agreement
+ *
+ * The software supplied herewith by Microchip Technology Incorporated
+ * (the 鼎ompany・ for its PICmicroｮ Microcontroller is intended and
+ * supplied to you, the Company痴 customer, for use solely and
+ * exclusively on Microchip PICmicro Microcontroller products. The
+ * software is owned by the Company and/or its supplier, and is
+ * protected under applicable copyright laws. All rights are reserved.
+ * Any use in violation of the foregoing restrictions may subject the
+ * user to criminal sanctions under applicable laws, as well as to
+ * civil liability for the breach of the terms and conditions of this
+ * license.
+ *
+ * THIS SOFTWARE IS PROVIDED IN AN 鄭S IS・CONDITION. NO WARRANTIES,
+ * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
+ * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
+ * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
+ * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
+ *
+*****************************************************************************/
+
+#ifndef  FS_DOT_H
+#define  FS_DOT_H
+
+#define ALLOW_FILESEARCH
+#define ALLOW_WRITES
+#define ALLOW_DIRS
+#define SUPPORT_FAT32
+
+#define MDD_MediaInitialize     MDD_SDSPI_MediaInitialize
+#define MDD_MediaDetect         MDD_SDSPI_MediaDetect
+#define MDD_SectorRead          MDD_SDSPI_SectorRead
+#define MDD_SectorWrite         MDD_SDSPI_SectorWrite
+#define MDD_InitIO              MDD_SDSPI_InitIO
+#define MDD_ShutdownMedia       MDD_SDSPI_ShutdownMedia
+#define MDD_WriteProtectState   MDD_SDSPI_WriteProtectState
+
+// Summary: An enumeration used for various error codes.
+// Description: The CETYPE enumeration is used to indicate different error conditions during device operation.
+typedef enum _CETYPE
+{
+    CE_GOOD = 0,                    // No error
+    CE_ERASE_FAIL,                  // An erase failed
+    CE_NOT_PRESENT,                 // No device was present
+    CE_NOT_FORMATTED,               // The disk is of an unsupported format
+    CE_BAD_PARTITION,               // The boot record is bad
+    CE_UNSUPPORTED_FS,              // The file system type is unsupported
+    CE_INIT_ERROR,                  // An initialization error has occured
+    CE_NOT_INIT,                    // An operation was performed on an uninitialized device
+    CE_BAD_SECTOR_READ,             // A bad read of a sector occured
+    CE_WRITE_ERROR,                 // Could not write to a sector
+    CE_INVALID_CLUSTER,             // Invalid cluster value > maxcls
+    CE_FILE_NOT_FOUND,              // Could not find the file on the device
+    CE_DIR_NOT_FOUND,               // Could not find the directory
+    CE_BAD_FILE,                    // File is corrupted
+    CE_DONE,                        // No more files in this directory
+    CE_COULD_NOT_GET_CLUSTER,       // Could not load/allocate next cluster in file
+    CE_FILENAME_2_LONG,             // A specified file name is too long to use
+    CE_FILENAME_EXISTS,             // A specified filename already exists on the device
+    CE_INVALID_FILENAME,            // Invalid file name
+    CE_DELETE_DIR,                  // The user tried to delete a directory with FSremove
+    CE_DIR_FULL,                    // All root dir entry are taken
+    CE_DISK_FULL,                   // All clusters in partition are taken
+    CE_DIR_NOT_EMPTY,               // This directory is not empty yet, remove files before deleting
+    CE_NONSUPPORTED_SIZE,           // The disk is too big to format as FAT16
+    CE_WRITE_PROTECTED,             // Card is write protected
+    CE_FILENOTOPENED,               // File not opened for the write
+    CE_SEEK_ERROR,                  // File location could not be changed successfully
+    CE_BADCACHEREAD,                // Bad cache read
+    CE_CARDFAT32,                   // FAT 32 - card not supported
+    CE_READONLY,                    // The file is read-only
+    CE_WRITEONLY,                   // The file is write-only
+    CE_INVALID_ARGUMENT,            // Invalid argument
+    CE_TOO_MANY_FILES_OPEN,         // Too many files are already open
+    CE_UNSUPPORTED_SECTOR_SIZE      // Unsupported sector size
+} CETYPE;
+
+
+// Summary: A macro indicating a dir entry was found
+// Description: The FOUND macro indicates that a directory entry was found in the specified position
+#define FOUND       0
+
+// Summary: A macro indicating no dir entry was found
+// Description: The NOT_FOUND macro indicates that the specified directory entry to load was deleted
+#define NOT_FOUND   1
+
+// Summary: A macro indicating that no more files were found
+// Description: The NO_MORE macro indicates that there are no more directory entries to search for
+#define NO_MORE     2
+
+
+
+// Summary: A macro indicating the device is formatted with FAT12
+// Description: The FAT12 macro is used to indicate that the file system on the device being accessed is a FAT12 file system.
+#define FAT12       1
+
+// Summary: A macro indicating the device is formatted with FAT16
+// Description: The FAT16 macro is used to indicate that the file system on the device being accessed is a FAT16 file system.
+#define FAT16       2
+
+// Summary: A macro indicating the device is formatted with FAT32
+// Description: The FAT32 macro is used to indicate that the file system on the device being accessed is a FAT32 file system.
+#define FAT32       3
+
+
+
+// Summary: A read-only attribute macro
+// Description: A macro for the read-only attribute.  A file with this attribute should not be written to.  Note that this
+//              attribute will not actually prevent a write to the file; that functionality is operating-system dependant.  The
+//              user should take care not to write to a read-only file.
+#define ATTR_READ_ONLY      0x01
+
+// Summary: A hidden attribute macro
+// Description: A macro for the hidden attribute.  A file with this attribute may be hidden from the user, depending on the
+//              implementation of the operating system.
+#define ATTR_HIDDEN         0x02
+
+// Summary: A system attribute macro
+// Description: A macro for the system attribute.  A file with this attribute is used by the operating system, and should not be
+//              modified.  Note that this attribute will not actually prevent a write to the file.
+#define ATTR_SYSTEM         0x04
+
+// Summary: A volume attribute macro
+// Description: A macro for the volume attribute.  If the first directory entry in the root directory has the volume attribute set,
+//              the device will use the name in that directory entry as the volume name.
+#define ATTR_VOLUME         0x08
+
+// Summary: A macro for the attributes for a long-file name entry
+// Description: A macro for the long-name attributes.  If a directory entry is used in a long-file name implementation, it will have
+//              all four lower bits set.  This indicates that any software that does not support long file names should ignore that
+//              entry.
+#define ATTR_LONG_NAME      0x0f
+
+// Summary: A directory attribute macro
+// Description: A macro for the directory attribute.  If a directory entry has this attribute set, the file it points to is a directory-
+//              type file, and will contain directory entries that point to additional directories or files.
+#define ATTR_DIRECTORY      0x10
+
+// Summary: An archive attribute macro
+// Description: A macro for the archive attribute.  This attribute will indicate to some archiving programs that the file with this
+//              attribute needs to be backed up.  Most operating systems create files with the archive attribute set.
+#define ATTR_ARCHIVE        0x20
+
+// Summary: A macro for all attributes
+// Description: A macro for all attributes.  The search functions in this library require an argument that determines which attributes
+//              a file is allowed to have in order to be found.  If ATTR_MASK is specified as this argument, any file may be found, regardless
+//              of its attributes.
+#define ATTR_MASK           0x3f
+
+
+
+// Summary: A macro to indicate an empty FAT entry
+// Description: The CLUSTER_EMPTY value is used to indicate that a FAT entry and it's corresponding cluster are available.
+#define CLUSTER_EMPTY               0x0000 
+
+// Summary: A macro to indicate the last cluster value for FAT12
+// Description: The LAST_CLUSTER_FAT12 macro is used when reading the FAT to indicate that the next FAT12 entry for a file contains
+//              the end-of-file value.
+#define LAST_CLUSTER_FAT12          0xff8
+
+// Summary: A macro to indicate the last cluster value for FAT16
+// Description: The LAST_CLUSTER_FAT16 macro is used when reading the FAT to indicate that the next FAT16 entry for a file contains
+//              the end-of-file value.
+#define LAST_CLUSTER_FAT16          0xfff8
+
+// Summary: A macro to indicate the last allocatable cluster for FAT12
+// Description: The END_CLUSTER_FAT12 value is used as a comparison in FAT12 to determine that the firmware has reached the end of
+//              the range of allowed allocatable clusters.
+#define END_CLUSTER_FAT12           0xFF7
+
+// Summary: A macro to indicate the last allocatable cluster for FAT16
+// Description: The END_CLUSTER_FAT16 value is used as a comparison in FAT16 to determine that the firmware has reached the end of
+//              the range of allowed allocatable clusters.
+#define END_CLUSTER_FAT16           0xFFF7
+
+// Summary: A macro to indicate the failure of the ReadFAT function
+// Description: The CLUSTER_FAIL_FAT16 macro is used by the ReadFAT function to indicate that an error occured reading a FAT12 or FAT16
+//              file allocation table.  Note that since '0xFFF8' is used for the last cluster return value in the FAT16 implementation
+//              the end-of-file value '0xFFFF' can be used to indicate an error condition.
+#define CLUSTER_FAIL_FAT16          0xFFFF
+
+
+
+#ifdef SUPPORT_FAT32
+    // Summary: A macro to indicate the last cluster value for FAT32
+    // Description: The LAST_CLUSTER_FAT32 macro is used when reading the FAT to indicate that the next FAT32 entry for a file contains
+    //              the end-of-file value.
+    #define LAST_CLUSTER_FAT32      0x0FFFFFF8
+
+    // Summary: A macro to indicate the last allocatable cluster for FAT32
+    // Description: The END_CLUSTER_FAT32 value is used as a comparison in FAT32 to determine that the firmware has reached the end of
+    //              the range of allowed allocatable clusters.
+    #define END_CLUSTER_FAT32       0x0FFFFFF7
+
+    // Summary: A macro to indicate the failure of the ReadFAT function
+    // Description: The CLUSTER_FAIL_FAT32 macro is used by the ReadFAT function to indicate that an error occured reading a FAT32
+    //              file allocation able.
+    #define CLUSTER_FAIL_FAT32      0x0FFFFFFF
+
+#endif
+
+// Summary: A macro indicating the number of bytes in a directory entry.
+// Description: The NUMBER_OF_BYTES_IN_DIR_ENTRY macro represents the number of bytes in one directory entry.  It is used to calculate
+//              the number of sectors in the root directory based on information in the boot sector.
+#define NUMBER_OF_BYTES_IN_DIR_ENTRY    32
+
+
+
+// Summary: A macro for a deleted dir entry marker.
+// Description: The DIR_DEL macro is used to mark a directory entry as deleted.  When a file is deleted, this value will replace the
+//              first character in the file name, and will indicate that the file the entry points to was deleted.
+#define DIR_DEL             0xE5
+
+// Summary: A macro for the last dir entry marker.
+// Description: The DIR_EMPTY macro is used to indicate the last entry in a directory.  Since entries in use cannot start with a 0 and
+//              deleted entries start with the DIR_DEL character, a 0 will mark the end of the in-use or previously used group of
+//              entries in a directory
+#define DIR_EMPTY           0
+
+
+
+// Summary: A macro used to indicate the length of an 8.3 file name
+// Description: The DIR_NAMESIZE macro is used when validing the name portion of 8.3 filenames
+#define DIR_NAMESIZE        8
+
+// Summary: A macro used to indicate the length of an 8.3 file extension
+// Description: The DIR_EXTENSION macro is used when validating the extension portion of 8.3 filenames
+#define DIR_EXTENSION       3
+
+// Summary: A macro used to indicate the length of an 8.3 file name and extension
+// Description: The DIR_NAMECOMP macro is used when validating 8.3 filenames
+#define DIR_NAMECOMP        (DIR_NAMESIZE+DIR_EXTENSION)
+
+
+
+// Summary: A macro to write a byte to RAM
+// Description: The RAMwrite macro is used to write a byte of data to a RAM array
+#define RAMwrite( a, f, d) *(a+f) = d
+
+// Summary: A macro to read a byte from RAM
+// Description: The RAMread macro is used to read a byte of data from a RAM array
+#define RAMread( a, f)  *(a+f)
+
+// Summary: A macro to read a 16-bit word from RAM
+// Description: The RAMreadW macro is used to read two bytes of data from a RAM array
+#define RAMreadW( a, f) *(WORD *)(a+f)
+
+// Summary: A macro to read a 32-bit word from RAM
+// Description: The RAMreadD macro is used to read four bytes of data from a RAM array
+#define RAMreadD( a, f) *(DWORD *)(a+f)
+
+
+
+#ifndef EOF
+    // Summary: Indicates error conditions or end-of-file conditions
+    // Description: The EOF macro is used to indicate error conditions in some function calls.  It is also used to indicate
+    //              that the end-of-file has been reached.
+    #define EOF             ((int)-1)
+#endif
+
+
+
+// Summary: A structure containing information about the device.
+// Description: The DISK structure contains information about the device being accessed.
+typedef struct
+{ 
+    BYTE    *   buffer;         // Address of the global data buffer used to read and write file information
+    DWORD       firsts;         // Logical block address of the first sector of the FAT partition on the device
+    DWORD       fat;            // Logical block address of the FAT
+    DWORD       root;           // Logical block address of the root directory
+    DWORD       data;           // Logical block address of the data section of the device.
+    WORD        maxroot;        // The maximum number of entries in the root directory.
+    DWORD       maxcls;         // The maximum number of clusters in the partition.
+    DWORD       sectorSize;     // The size of a sector in bytes
+    DWORD       fatsize;        // The number of sectors in the FAT
+    BYTE        fatcopy;        // The number of copies of the FAT in the partition
+    BYTE        SecPerClus;     // The number of sectors per cluster in the data region
+    BYTE        type;           // The file system type of the partition (FAT12, FAT16 or FAT32)
+    BYTE        mount;          // Device mount flag (TRUE if disk was mounted successfully, FALSE otherwise)
+#if defined __PIC32MX__ || defined __C30__
+} __attribute__ ((packed)) DISK;
+#else
+} DISK;
+#endif
+
+
+#ifdef __18CXX
+    // Summary: A 24-bit data type
+    // Description: The SWORD macro is used to defined a 24-bit data type.  For 16+ bit architectures, this must be represented as
+    //              an array of three bytes.
+    typedef unsigned short long SWORD;
+#else
+    // Summary: A 24-bit data type
+    // Description: The SWORD macro is used to defined a 24-bit data type.  For 16+ bit architectures, this must be represented as
+    //              an array of three bytes.
+    typedef struct
+    {
+        unsigned char array[3];
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) SWORD;
+#else
+    } SWORD;
+#endif
+#endif
+
+
+
+// Summary: A structure containing the bios parameter block for a FAT12 file system (in the boot sector)
+// Description: The _BPB_FAT12 structure provides a layout of the "bios parameter block" in the boot sector of a FAT12 partition.
+typedef struct {
+    SWORD BootSec_JumpCmd;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD BootSec_BPS;               // Number of bytes per sector
+    BYTE  BootSec_SPC;              // Number of sectors per cluster
+    WORD BootSec_ResrvSec;          // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_FATCount;         // Number of FATs on the partition
+    WORD BootSec_RootDirEnts;       // Number of root directory entries
+    WORD BootSec_TotSec16;          // Total number of sectors
+    BYTE  BootSec_MDesc;            // Media descriptor
+    WORD BootSec_SPF;               // Number of sectors per FAT
+    WORD BootSec_SPT;               // Number of sectors per track
+    WORD BootSec_HeadCnt;           // Number of heads
+    DWORD BootSec_HiddenSecCnt;     // Number of hidden sectors
+    DWORD  BootSec_Reserved;        // Reserved space
+    BYTE  BootSec_DriveNum;         // Drive number
+    BYTE  BootSec_Reserved2;        // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - equal to 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLabel[11];     // Volume Label
+    BYTE  BootSec_FSType[8];        // File system type in ASCII. Not used for determination   
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT12;
+#else
+    } _BPB_FAT12;
+#endif
+
+// Summary: A structure containing the bios parameter block for a FAT16 file system (in the boot sector)
+// Description: The _BPB_FAT16 structure provides a layout of the "bios parameter block" in the boot sector of a FAT16 partition.
+typedef struct {
+    SWORD BootSec_JumpCmd;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD  BootSec_BPS;              // Number of bytes per sector
+    BYTE  BootSec_SPC;              // Number of sectors per cluster
+    WORD  BootSec_ResrvSec;         // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_FATCount;         // Number of FATs on the partition
+    WORD  BootSec_RootDirEnts;      // Number of root directory entries
+    WORD  BootSec_TotSec16;         // Total number of sectors
+    BYTE  BootSec_MDesc;            // Media descriptor
+    WORD  BootSec_SPF;              // Number of sectors per FAT
+    WORD  BootSec_SPT;              // Number of sectors per track
+    WORD  BootSec_HeadCnt;          // Number of heads
+    DWORD BootSec_HiddenSecCnt;     // Number of hidden sectors
+    DWORD BootSec_TotSec32;         // Total sector count (32 bits)
+    BYTE  BootSec_DriveNum;         // Drive number
+    BYTE  BootSec_Reserved;         // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - equal to 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLabel[11];     // Volume Label
+    BYTE  BootSec_FSType[8];        // File system type in ASCII. Not used for determination     
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT16;
+#else
+    } _BPB_FAT16;
+#endif
+
+// Summary: A structure containing the bios parameter block for a FAT32 file system (in the boot sector)
+// Description: The _BPB_FAT32 structure provides a layout of the "bios parameter block" in the boot sector of a FAT32 partition.
+typedef struct {
+    SWORD BootSec_jmpBoot;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD BootSec_BytsPerSec;        // Number of bytes per sector
+    BYTE  BootSec_SecPerClus;       // Number of sectors per cluster
+    WORD BootSec_RsvdSecCnt;        // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_NumFATs;          // Number of FATs on the partition
+    WORD BootSec_RootEntCnt;        // Number of root directory entries
+    WORD BootSec_TotSec16;          // Total number of sectors
+    BYTE  BootSec_Media;            // Media descriptor
+    WORD BootSec_FATSz16;           // Number of sectors per FAT
+    WORD BootSec_SecPerTrk;         // Number of sectors per track
+    WORD BootSec_NumHeads;          // Number of heads
+    DWORD BootSec_HiddSec;          // Number of hidden sectors
+    DWORD BootSec_TotSec32;         // Total sector count (32 bits)
+    DWORD BootSec_FATSz32;          // Sectors per FAT (32 bits)
+    WORD BootSec_ExtFlags;          // Presently active FAT. Defined by bits 0-3 if bit 7 is 1.
+    WORD BootSec_FSVers;            // FAT32 filesystem version.  Should be 0:0
+    DWORD BootSec_RootClus;         // Start cluster of the root directory (should be 2)
+    WORD BootSec_FSInfo;            // File system information
+    WORD BootSec_BkBootSec;         // Backup boot sector address.
+    BYTE  BootSec_Reserved[12];     // Reserved space
+    BYTE  BootSec_DrvNum;           // Drive number
+    BYTE  BootSec_Reserved1;        // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLab[11];       // Volume Label
+    BYTE  BootSec_FilSysType[8];    // File system type in ASCII.  Not used for determination  
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT32;
+#else
+    } _BPB_FAT32;
+#endif
+
+
+// Description: A macro for the boot sector bytes per sector value offset
+#define BSI_BPS            11
+
+// Description: A macro for the boot sector sector per cluster value offset
+#define BSI_SPC            13
+
+// Description: A macro for the boot sector reserved sector count value offset
+#define BSI_RESRVSEC       14
+
+// Description: A macro for the boot sector FAT count value offset
+#define BSI_FATCOUNT       16
+
+// Description: A macro for the boot sector root directory entry count value offset
+#define BSI_ROOTDIRENTS    17
+
+// Description: A macro for the boot sector 16-bit total sector count value offset
+#define BSI_TOTSEC16       19
+
+// Description: A macro for the boot sector sectors per FAT value offset
+#define BSI_SPF            22
+
+// Description: A macro for the boot sector 32-bit total sector count value offset
+#define BSI_TOTSEC32       32
+
+// Description: A macro for the boot sector boot signature offset
+#define BSI_BOOTSIG        38
+
+// Description: A macro for the boot sector file system type string offset
+#define BSI_FSTYPE         54
+
+// Description: A macro for the boot sector 32-bit sector per FAT value offset
+#define  BSI_FATSZ32       36
+
+// Description: A macro for the boot sector start cluster of root directory value offset
+#define  BSI_ROOTCLUS      44
+
+// Description: A macro for the FAT32 boot sector boot signature offset
+#define  BSI_FAT32_BOOTSIG 66
+
+// Description: A macro for the FAT32 boot sector file system type string offset
+#define  BSI_FAT32_FSTYPE  82
+
+
+
+// Summary: A partition table entry structure.
+// Description: The PTE_MBR structure contains values found in a partition table entry in the MBR of a device.
+typedef struct
+{
+    BYTE      PTE_BootDes;            // The boot descriptor (should be 0x00 in a non-bootable device)
+    SWORD     PTE_FrstPartSect;       // The cylinder-head-sector address of the first sector of the partition
+    BYTE      PTE_FSDesc;             // The file system descriptor
+    SWORD     PTE_LstPartSect;        // The cylinder-head-sector address of the last sector of the partition
+    DWORD     PTE_FrstSect;           // The logical block address of the first sector of the partition
+    DWORD     PTE_NumSect;            // The number of sectors in a partition
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) PTE_MBR;
+#else
+    } PTE_MBR;
+#endif
+
+
+// Summary: A structure of the organization of a master boot record.
+// Description: The _PT_MBR structure has the same form as a master boot record.  When the MBR is loaded from the device, it will
+//              be cast as a _PT_MBR structure so the MBR elements can be accessed.
+typedef struct
+{
+    BYTE        ConsChkRtn[446];        // Boot code
+    PTE_MBR     Partition0;             // The first partition table entry
+    PTE_MBR     Partition1;             // The second partition table entry
+    PTE_MBR     Partition2;             // The third partition table entry
+    PTE_MBR     Partition3;             // The fourth partition table entry
+    BYTE        Signature0;             // MBR signature code - equal to 0x55
+    BYTE        Signature1;             // MBR signature code - equal to 0xAA
+#if defined __PIC32MX__ || defined __C30__
+}__attribute__((packed)) _PT_MBR;
+#else
+}_PT_MBR;
+#endif
+
+// Summary: A pointer to a _PT_MBR structure
+// Description: The PT_MBR pointer points to a _PT_MBR structure.
+typedef _PT_MBR *  PT_MBR;
+
+
+
+// Summary: A structure of the organization of a boot sector.
+// Description: The _BootSec structure has the same form as a boot sector.  When the boot sector is loaded from the device, it will
+//              be cast as a _BootSec structure so the boot sector elements can be accessed.
+typedef struct
+{
+    // A union of different bios parameter blocks
+    union
+    {
+        _BPB_FAT32  FAT_32;
+        _BPB_FAT16  FAT_16;
+        _BPB_FAT12  FAT_12;
+    }FAT;
+    BYTE    Reserved[512-sizeof(_BPB_FAT32)-2]; // Reserved space
+    BYTE    Signature0;         // Boot sector signature code - equal to 0x55
+    BYTE    Signature1;         // Boot sector signature code - equal to 0xAA
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BootSec;
+#else
+    } _BootSec;
+#endif
+
+// Summary: A pointer to a _BootSec structure
+// Description: The BootSec pointer points to a _BootSec structure.
+typedef _BootSec * BootSec;
+
+
+
+// Summary: A macro indicating the offset for the master boot record
+// Description: FO_MBR is a macro that indicates the addresss of the master boot record on the device.  When the device is initialized
+//              this sector will be read
+#define FO_MBR          0L
+
+
+
+// Summary: A macro for the first boot sector/MBR signature byte
+// Description: The FAT_GOOD_SIGN_0 macro is used to determine that the first byte of the MBR or boot sector signature code is correct
+#define FAT_GOOD_SIGN_0     0x55
+
+// Summary: A macro for the second boot sector/MBR signature byte
+// Description: The FAT_GOOD_SIGN_1 macro is used to determine that the second byte of the MBR or boot sector signature code is correct
+#define FAT_GOOD_SIGN_1     0xAA
+
+
+typedef struct 
+{
+    BYTE    errorCode;
+    union 
+    {
+        BYTE    value;
+        struct 
+        {
+            BYTE    sectorSize  : 1;
+            BYTE    maxLUN      : 1;
+        }   bits;
+    } validityFlags;
+    
+    WORD    sectorSize;
+    BYTE    maxLUN;
+} MEDIA_INFORMATION;
+
+typedef enum
+{
+    MEDIA_NO_ERROR,                     // No errors
+    MEDIA_DEVICE_NOT_PRESENT,           // The requested device is not present
+    MEDIA_CANNOT_INITIALIZE             // Cannot initialize media
+} MEDIA_ERRORS;                
+
+
+/*******************************************************************/
+/*                     Strunctures and defines                     */
+/*******************************************************************/
+
+#ifndef FALSE
+    // Summary: False value
+    // Description:  This macro will indicate that a condition is false.
+    #define FALSE   0
+#endif
+#ifndef TRUE
+    // Summary: True value
+    // Description: This macro will indicate that a condition is true.
+    #define TRUE    !FALSE  // True value
+#endif
+
+
+
+
+#ifndef SEEK_SET
+    // Summary: Macro for the FSfseek SEEK_SET base location.
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed 
+    //              relative to the beginning of the file.
+    #define SEEK_SET 0
+
+#endif
+#ifndef SEEK_CUR
+
+    // Summary: Macro for the FSfseek SEEK_CUR base location.
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed
+    //              relative to the current location of the file
+    #define SEEK_CUR 1
+
+#endif
+#ifndef SEEK_END
+
+    // Summary: Macro for the FSfseek SEEK_END base location
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed
+    //              relative to the end of the file.  For this macro, the offset value will be subtracted from
+    //              the end location of the file by default.
+    #define SEEK_END 2
+
+#endif
+
+
+
+
+// Summary: Macro for the FSfopen FS_APPEND mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it's file information will be loaded and the
+//              current location in the file will be set to the end.  The user will then be able to write to the file.
+#define FS_APPEND   "a"
+#define APPEND  "a"     //deprecated
+
+// Summary: Macro for the FSfopen FS_WRITE mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it will be erased and replaced by an empty file
+//              of the same name.  The user will then be able to write to the file.
+#define FS_WRITE    "w"
+#define WRITE   "w"     //deprecated
+
+// Summary: Macro for the FSfopen FS_READ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file information for the 
+//              specified file will be loaded.  If the file does not exist, the FSfopen function will fail.  The user 
+//              will then be able to read from the file.
+#define FS_READ "r"
+#if defined(__32MX795F512L__)
+//    #warning FSfopen must use "r" and not READ as input on this device
+#else
+    #define READ    "r"     //deprecated
+#endif
+
+// Summary: Macro for the FSfopen FS_APPEND+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it's file information will be loaded and the
+//              current location in the file will be set to the end.  The user will then be able to write to the file
+//              or read from the file.
+#define FS_APPENDPLUS   "a+"
+#define APPENDPLUS "a+"     //deprecated
+
+// Summary: Macro for the FSfopen FS_WRITE+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it will be erased and replaced by an empty file
+//              of the same name.  The user will then be able to write to the file or read from the file.
+#define FS_WRITEPLUS    "w+"
+#define WRITEPLUS  "w+"     //deprecated
+
+// Summary: Macro for the FSfopen FS_READ+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file information for the 
+//              specified file will be loaded.  If the file does not exist, the FSfopen function will fail.  The user 
+//              will then be able to read from the file or write to the file.
+#define FS_READPLUS     "r+"
+#define READPLUS   "r+"     //deprecated
+
+
+
+#ifndef intmax_t
+    #ifdef __PIC24F__
+        // Summary: A data type indicating the maximum integer size in an architecture
+        // Description: The intmax_t data type refers to the maximum-sized data type on any given architecture.  This
+        //              data type can be specified as a format specifier size specification for the FSfprintf function.
+        #define intmax_t long long
+    #elif defined __PIC24H__
+        #define intmax_t long long
+    #elif defined __dsPIC30F__
+        #define intmax_t long long
+    #elif defined __dsPIC33F__
+        #define intmax_t long long
+    #endif
+#endif
+
+
+
+// Summary:  Indicates flag conditions for a file object
+// Description: The FILEFLAGS structure is used to indicate conditions in a file.  It contains three flags: 'write' indicates
+//              that the file was opened in a mode that allows writes, 'read' indicates that the file was opened in a mode
+//              that allows reads, and 'FileWriteEOF' indicates that additional data that is written to the file will increase
+//              the file size.
+typedef struct
+{
+    unsigned    write :1;           // Indicates a file was opened in a mode that allows writes
+    unsigned    read :1;            // Indicates a file was opened in a mode that allows reads
+    unsigned    FileWriteEOF :1;    // Indicates the current position in a file is at the end of the file
+}FILEFLAGS;
+
+
+
+// Summary: Indicates how to search for file entries in the FILEfind function
+// Description: The values in the SEARCH_TYPE enumeration are used internally by the library to indicate how the FILEfind function
+//              how to perform a search.  The 'LOOK_FOR_EMPTY_ENTRY' value indicates that FILEfind should search for an empty file entry.
+//              The 'LOOK_FOR_MATCHING_ENTRY' value indicates that FILEfind should search for an entry that matches the FSFILE object
+//              that was passed into the FILEfind function.
+typedef enum{
+    LOOK_FOR_EMPTY_ENTRY = 0,
+    LOOK_FOR_MATCHING_ENTRY
+} SEARCH_TYPE;
+
+
+
+// Summary: Macro indicating the length of a 8.3 file name
+// Description: The TOTAL_FILE_SIZE_8P3 macro indicates the maximum number of characters in an 8.3 file name.  This value includes
+//              8 characters for the name, three for the extentsion, and 1 for the radix ('.')
+#define TOTAL_FILE_SIZE_8P3             (8+3+1)
+#define TOTAL_FILE_SIZE                 TOTAL_FILE_SIZE_8P3
+
+// Summary: Macro indicating the max length of a LFN file name
+// Description: The MAX_FILE_NAME_LENGTH_LFN macro indicates the maximum number of characters in an LFN file name.
+#define MAX_FILE_NAME_LENGTH_LFN             256
+
+// Summary: A mask that indicates the limit of directory entries in a sector
+// Description: The MASK_MAX_FILE_ENTRY_LIMIT_BITS is used to indicate to the Cache_File_Entry function that a new sector needs to
+//              be loaded.
+#define MASK_MAX_FILE_ENTRY_LIMIT_BITS          0x0f
+
+// Summary: Value used for shift operations to calculate the sector offset in a directory
+// Description: The VALUE_BASED_ON_ENTRIES_PER_CLUSTER macro is used to calculate sector offsets for directories.  The position of the
+//              entry is shifted by 4 bits (divided by 16, since there are 16 entries in a sector) to calculate how many sectors a
+//              specified entry is offset from the beginning of the directory.
+#define VALUE_BASED_ON_ENTRIES_PER_CLUSTER      4
+
+// Summary: A value that will indicate that a dotdot directory entry points to the root.
+// Description: The VALUE_DOTDOT_CLUSTER_VALUE_FOR_ROOT macro is used as an absolute address when writing information to a dotdot entry
+//              in a newly created directory.  If a dotdot entry points to the root directory, it's cluster value must be set to 0,
+//              regardless of the actual cluster number of the root directory.
+#define VALUE_DOTDOT_CLUSTER_VALUE_FOR_ROOT     0
+
+// Summary: MAcro indicating the length of an 8.3 file name in a directory entry
+// Description: The FILE_NAME_SIZE_8P3 macro indicates the number of characters that an 8.3 file name will take up when packed in
+//              a directory entry.  This value includes 8 characters for the name and 3 for the extension.  Note that the radix is not
+//              stored in the directory entry.
+#define FILE_NAME_SIZE_8P3           11
+#define FILE_NAME_SIZE               FILE_NAME_SIZE_8P3
+
+
+// Summary: Contains file information and is used to indicate which file to access.
+// Description: The FSFILE structure is used to hold file information for an open file as it's being modified or accessed.  A pointer to 
+//              an open file's FSFILE structure will be passeed to any library function that will modify that file.
+typedef struct
+{
+    DISK    *       dsk;            // Pointer to a DISK structure
+    DWORD           cluster;        // The first cluster of the file
+    DWORD           ccls;           // The current cluster of the file
+    WORD            sec;            // The current sector in the current cluster of the file
+    WORD            pos;            // The position in the current sector
+    DWORD           seek;           // The absolute position in the file
+    DWORD           size;           // The size of the file
+    FILEFLAGS       flags;          // A structure containing file flags
+    WORD            time;           // The file's last update time
+    WORD            date;           // The file's last update date
+    char            name[FILE_NAME_SIZE_8P3];       // The short name of the file
+	#ifdef SUPPORT_LFN
+    	BOOL			AsciiEncodingType;          // Ascii file name or Non-Ascii file name indicator
+		unsigned short int *utf16LFNptr;	        // Pointer to long file name in UTF16 format
+		unsigned short int utf16LFNlength;          // LFN length in terms of words including the NULL word at the last.
+	#endif
+    WORD            entry;          // The position of the file's directory entry in it's directory
+    WORD            chk;            // File structure checksum
+    WORD            attributes;     // The file attributes
+    DWORD           dirclus;        // The base cluster of the file's directory
+    DWORD           dirccls;        // The current cluster of the file's directory
+} FSFILE;
+
+/* Summary: Possible results of the FSGetDiskProperties() function.
+** Description: See the FSGetDiskProperties() function for more information.
+*/
+typedef enum
+{
+    FS_GET_PROPERTIES_NO_ERRORS = 0,
+    FS_GET_PROPERTIES_DISK_NOT_MOUNTED,
+    FS_GET_PROPERTIES_CLUSTER_FAILURE,
+    FS_GET_PROPERTIES_STILL_WORKING = 0xFF
+} FS_DISK_ERRORS;
+
+
+/* Summary: Contains the disk search information, intermediate values, and results
+** Description: This structure is used in conjunction with the FSGetDiskProperties()
+**              function.  See that function for more information about the usage.
+*/
+typedef struct
+{
+    DISK *  disk;           /* pointer to the disk we are searching */
+    BOOL    new_request;    /* is this a new request or a continued request */
+    FS_DISK_ERRORS properties_status;  /* status of the last call of the function */
+
+    struct
+    {
+        BYTE disk_format;           /* disk format: FAT12, FAT16, FAT32 */
+        WORD sector_size;           /* sector size of the drive */
+        BYTE sectors_per_cluster;   /* number of sectors per cluster */
+        DWORD total_clusters;       /* the number of total clusters on the drive */
+        DWORD free_clusters;        /* the number of free (unused) clusters on drive */
+    } results;                      /* the results of the current search */
+
+    struct
+    {
+        DWORD   c;     
+        DWORD   curcls;
+        DWORD   EndClusterLimit;
+        DWORD   ClusterFailValue;
+    } private;      /* intermediate values used to continue searches.  This
+                         member should be used only by the FSGetDiskProperties()
+                         function */
+
+} FS_DISK_PROPERTIES;
+
+// Summary: A structure used for searching for files on a device.
+// Description: The SearchRec structure is used when searching for file on a device.  It contains parameters that will be loaded with
+//              file information when a file is found.  It also contains the parameters that the user searched for, allowing further
+//              searches to be perfomed in the same directory for additional files that meet the specified criteria.
+typedef struct
+{
+    char            filename[FILE_NAME_SIZE_8P3 + 2];   // The name of the file that has been found
+    unsigned char   attributes;                     // The attributes of the file that has been found
+    unsigned long   filesize;                       // The size of the file that has been found
+    unsigned long   timestamp;                      // The last modified time of the file that has been found (create time for directories)
+	#ifdef SUPPORT_LFN
+		BOOL			AsciiEncodingType;          // Ascii file name or Non-Ascii file name indicator
+		unsigned short int *utf16LFNfound;		    // Pointer to long file name found in UTF16 format
+		unsigned short int utf16LFNfoundLength;     // LFN Found length in terms of words including the NULL word at the last.
+	#endif
+    unsigned int    entry;                          // The directory entry of the last file found that matches the specified attributes. (Internal use only)
+    char            searchname[FILE_NAME_SIZE_8P3 + 2]; // The 8.3 format name specified when the user began the search. (Internal use only)
+    unsigned char   searchattr;                     // The attributes specified when the user began the search. (Internal use only)
+    unsigned long   cwdclus;                        // The directory that this search was performed in. (Internal use only)
+    unsigned char   initialized;                    // Check to determine if the structure was initialized by FindFirst (Internal use only)
+} SearchRec;
+
+
+/***************************************************************************
+* Prototypes                                                               *
+***************************************************************************/
+
+
+
+
+/*************************************************************************
+  Function:
+    int FSInit(void)
+  Summary:
+    Function to initialize the device.
+  Conditions:
+    The physical device should be connected to the microcontroller.
+  Input:
+    None
+  Return Values:
+    TRUE -  Initialization successful
+    FALSE - Initialization unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    Initializes the static or dynamic memory slots for holding file
+    structures.  Initializes the device with the DISKmount function. Loads 
+    MBR and boot sector information.  Initializes the current working
+    directory to the root directory for the device if directory support
+    is enabled.
+  Remarks:
+    None
+  *************************************************************************/
+
+int FSInit(void);
+
+
+/*********************************************************************
+  Function:
+    FSFILE * FSfopen (const char * fileName, const char *mode)
+  Summary:
+    Open a Ascii file
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to open
+    mode -
+         - WRITE -      Create a new file or replace an existing file
+         - READ -       Read data from an existing file
+         - APPEND -     Append data to an existing file
+         - WRITEPLUS -  Create a new file or replace an existing file (reads also enabled)
+         - READPLUS -   Read data from an existing file (writes also enabled)
+         - APPENDPLUS - Append data to an existing file (reads also enabled)
+  Return Values:
+    FSFILE * - The pointer to the file object
+    NULL -     The file could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will open a file or directory.  First, RAM in the
+    dynamic heap or static array will be allocated to a new FSFILE object.
+    Then, the specified file name will be formatted to ensure that it's
+    in 8.3 format or LFN format. Next, the FILEfind function will be used
+    to search for the specified file name. If the name is found, one of three
+    things will happen: if the file was opened in read mode, its file
+    info will be loaded using the FILEopen function; if it was opened in
+    write mode, it will be erased, and a new file will be constructed in
+    its place; if it was opened in append mode, its file info will be
+    loaded with FILEopen and the current location will be moved to the
+    end of the file using the FSfseek function.  If the file was not
+    found by FILEfind, a new file will be created if the mode was specified as
+    a write or append mode.  In these cases, a pointer to the heap or
+    static FSFILE object array will be returned. If the file was not
+    found and the mode was specified as a read mode, the memory
+    allocated to the file will be freed and the NULL pointer value
+    will be returned.
+  Remarks:
+    None.
+  *********************************************************************/
+
+FSFILE * FSfopen(const char * fileName, const char *mode);
+
+#ifdef SUPPORT_LFN
+/*********************************************************************
+  Function:
+    FSFILE * wFSfopen (const unsigned short int * fileName, const char *mode)
+  Summary:
+    Open a UTF16 file.
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to open
+    mode -
+         - WRITE -      Create a new file or replace an existing file
+         - READ -       Read data from an existing file
+         - APPEND -     Append data to an existing file
+         - WRITEPLUS -  Create a new file or replace an existing file (reads also enabled)
+         - READPLUS -   Read data from an existing file (writes also enabled)
+         - APPENDPLUS - Append data to an existing file (reads also enabled)
+  Return Values:
+    FSFILE * - The pointer to the file object
+    NULL -     The file could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will open a file or directory.  First, RAM in the
+    dynamic heap or static array will be allocated to a new FSFILE object.
+    Then, the specified file name will be formatted to ensure that it's
+    in 8.3 format or LFN format. Next, the FILEfind function will be used
+    to search for the specified file name. If the name is found, one of three
+    things will happen: if the file was opened in read mode, its file
+    info will be loaded using the FILEopen function; if it was opened in
+    write mode, it will be erased, and a new file will be constructed in
+    its place; if it was opened in append mode, its file info will be
+    loaded with FILEopen and the current location will be moved to the
+    end of the file using the FSfseek function.  If the file was not
+    found by FILEfind, a new file will be created if the mode was specified as
+    a write or append mode.  In these cases, a pointer to the heap or
+    static FSFILE object array will be returned. If the file was not
+    found and the mode was specified as a read mode, the memory
+    allocated to the file will be freed and the NULL pointer value
+    will be returned.
+  Remarks:
+    None.
+  *********************************************************************/
+
+FSFILE * wFSfopen(const unsigned short int * fileName, const char *mode);
+#endif
+
+#ifdef ALLOW_PGMFUNCTIONS
+
+/******************************************************************************
+  Function:
+    FSFILE * FSfopenpgm(const rom char * fileName, const rom char *mode)
+  Summary:
+    Open a Ascii file named with a ROM string on PIC18
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to be opened (ROM)
+    mode -      The mode the file will be opened in (ROM)
+  Return Values:
+    FSFILE * - A pointer to the file object
+    NULL -     File could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfopenpgm function will copy a PIC18 ROM fileName and mode argument
+    into RAM arrays, and then pass those arrays to the FSfopen function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  ******************************************************************************/
+
+    FSFILE * FSfopenpgm(const rom char * fileName, const rom char *mode);
+
+
+/**************************************************************************************
+  Function:
+    int FindFirstpgm (const char * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Find a file named with a ROM string on PIC18
+  Conditions:
+    None
+  Input:
+    fileName -  The name of the file to be found (ROM)
+    attr -      The attributes of the file to be found
+    rec -       Pointer to a search record to store the file info in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the given parameters was found
+  Side Effects:
+    Search criteria from previous FindFirstpgm call on passed SearchRec object
+    will be lost.The FSerrno variable will be changed.
+  Description:
+    The FindFirstpgm function will copy a PIC18 ROM fileName argument
+    into a RAM array, and then pass that array to the FindFirst function.
+  Remarks:
+    Call FindFirstpgm or FindFirst before calling FindNext.
+    This function is for use with PIC18 when passing arguments in ROM.
+  **************************************************************************************/
+
+    int FindFirstpgm (const rom char * fileName, unsigned int attr, SearchRec * rec);
+
+
+/**************************************************************************
+  Function:
+    int FSchdirpgm (const rom char * path)
+  Summary:
+    Changed the CWD with a path in ROM on PIC18
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to (ROM)
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdirpgm function passes a PIC18 ROM path pointer to the
+    chdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM
+  **************************************************************************/
+
+    int FSchdirpgm (const rom char * path);
+
+    #ifdef ALLOW_WRITES
+
+
+/*************************************************************
+  Function:
+    int FSremovepgm (const rom char * fileName)
+  Summary:
+    Delete a file named with a ROM string on PIC18
+  Conditions:
+    File not opened; file exists
+  Input:
+    fileName -  The name of the file to be deleted (ROM)
+  Return Values:
+    0 -  File was removed successfully
+    -1 - File could not be removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSremovepgm function will copy a PIC18 ROM fileName argument
+    into a RAM array, and then pass that array to the FSremove function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  *************************************************************/
+
+        int FSremovepgm (const rom char * fileName);
+
+
+/**************************************************************************
+  Function:
+    int FSmkdirpgm (const rom char * path)
+  Summary:
+    Create a directory with a path in ROM on PIC18
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create (ROM)
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The FSmkdirpgm function passes a PIC18 ROM path pointer to the
+    mkdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arugments in ROM
+  **************************************************************************/
+
+        int FSmkdirpgm (const rom char * path);
+
+
+/**************************************************************************
+  Function:
+    int FSrmdirpgm (const rom char * path)
+  Summary:
+    Delete a directory with a path in ROM on PIC18
+  Conditions:
+    None.
+  Input:
+    path -      The path of the directory to remove (ROM)
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrmdirpgm function passes a PIC18 ROM path pointer to the
+    rmdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  **************************************************************************/
+
+        int FSrmdirpgm (const rom char * path, unsigned char rmsubdirs);
+
+
+/*****************************************************************
+  Function:
+    int FSrenamepgm(const rom char * fileName, FSFILE * fo)
+  Summary:
+    Rename a file named with a ROM string on PIC18
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file (in ROM)
+    fo -        The file to rename
+  Return Values:
+    0 -  File renamed successfully
+    -1 - File could not be renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The Fsrenamepgm function will copy the rom fileName specified
+    by the user into a RAM array and pass that array into the
+    FSrename function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.                       
+  *****************************************************************/
+
+        int FSrenamepgm (const rom char * fileName, FSFILE * fo);
+    #endif
+#endif
+
+
+/************************************************************
+  Function:
+    int FSfclose(FSFILE *fo)
+  Summary:
+    Update file information and free FSFILE objects
+  Conditions:
+    File opened
+  Input:
+    fo -  Pointer to the file to close
+  Return Values:
+    0 -   File closed successfully 
+    EOF - Error closing the file
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will update the directory entry for the 
+    file pointed to by 'fo' with the information contained
+    in 'fo,' including the new file size and attributes.
+    Timestamp information will also be loaded based on the
+    method selected by the user and written to the entry
+    as the last modified time and date.  The file entry will
+    then be written to the device.  Finally, the memory
+    used for the specified file object will be freed from
+    the dynamic heap or the array of FSFILE objects.
+  Remarks:
+    A function to flush data to the device without closing the
+    file can be created by removing the portion of this
+    function that frees the memory and the line that clears
+    the write flag.
+  ************************************************************/
+
+int FSfclose(FSFILE *fo);
+
+
+/*********************************************************
+  Function:
+    void FSrewind (FSFILE * fo)
+  Summary:
+    Set the current position in a file to the beginning
+  Conditions:
+    File opened.
+  Input:
+    fo -  Pointer to file structure
+  Return Values:
+    None
+  Side Effects:
+    None.
+  Description:
+    The FSrewind funciton will reset the position of the
+    specified file to the beginning of the file.  This
+    functionality is faster than using FSfseek to reset
+    the position in the file.
+  Remarks:
+    None.
+  *********************************************************/
+
+void FSrewind (FSFILE *fo);
+
+
+/**************************************************************************
+  Function:
+    size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream)
+  Summary:
+    Read data from a file
+  Conditions:
+    File is opened in a read mode
+  Input:
+    ptr -     Destination buffer for read bytes
+    size -    Size of units in bytes
+    n -       Number of units to be read
+    stream -  File to be read from
+  Return:
+    size_t - number of units read
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfread function will read data from the specified file.  First,
+    the appropriate sector of the file is loaded.  Then, data is read into
+    the specified buffer until the specified number of bytes have been read.
+    When a cluster boundary is reached, a new cluster will be loaded.  The
+    parameters 'size' and 'n' indicate how much data to read.  'Size'
+    refers to the size of one object to read (in bytes), and 'n' will refer 
+    to the number of these objects to read.  The value returned will be equal 
+    to 'n' unless an error occured or the user tried to read beyond the end
+    of the file.
+  Remarks:
+    None.
+  **************************************************************************/
+
+size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream);
+
+
+/**********************************************************************
+  Function:
+    int FSfseek(FSFILE *stream, long offset, int whence)
+  Summary:
+    Change the current position in a file
+  Conditions:
+    File opened
+  Input:
+    stream -    Pointer to file structure
+    offset -    Offset from base location
+    whence -    
+           - SEEK_SET -  Seek from start of file
+           - SEEK_CUR -  Seek from current location
+           - SEEK_END -  Seek from end of file (subtract offset)
+  Return Values:
+    0 -  Operation successful 
+    -1 - Operation unsuccesful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfseek function will change the current position in the file to
+    one specified by the user.  First, an absolute offset is calculated
+    using the offset and base location passed in by the user.  Then, the
+    position variables are updated, and the sector number that corresponds
+    to the new location.  That sector is then loaded.  If the offset
+    falls exactly on a cluster boundary, a new cluster will be allocated
+    to the file and the position will be set to the first byte of that
+    cluster.
+  Remarks:
+    None                                                               
+  **********************************************************************/
+
+int FSfseek(FSFILE *stream, long offset, int whence);
+
+
+/*******************************************************************
+  Function:
+    long FSftell (FSFILE * fo)
+  Summary:
+    Determine the current location in a file
+  Conditions:
+    File opened
+  Input:
+    fo -  Pointer to file structure
+  Return: Current location in the file
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSftell function will return the current position in the
+    file pointed to by 'fo' by returning the 'seek' variable in the
+    FSFILE object, which is used to keep track of the absolute
+    location of the current position in the file.
+  Remarks:
+    None                                                            
+  *******************************************************************/
+
+long FSftell(FSFILE *fo);
+
+
+/****************************************************
+  Function:
+    int FSfeof( FSFILE * stream )
+  Summary:
+    Indicate whether the current file position is at the end
+  Conditions:
+    File is open in a read mode
+  Input:
+    stream -  Pointer to the target file
+  Return Values:
+    Non-Zero - EOF reached 
+    0 - Not at end of File
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfeof function will indicate that the end-of-
+    file has been reached for the specified file by
+    comparing the absolute location in the file to the
+    size of the file.
+  Remarks:
+    None.
+  ****************************************************/
+
+int FSfeof( FSFILE * stream );
+
+
+#ifdef ALLOW_FORMATS
+/*******************************************************************
+  Function:
+    int FSformat (char mode, long int serialNumber, char * volumeID)
+  Summary:
+    Formats a device
+  Conditions:
+    The device must possess a valid master boot record.
+  Input:
+    mode -          - 0 - Just erase the FAT and root
+                    - 1 - Create a new boot sector
+    serialNumber -  Serial number to write to the card
+    volumeID -      Name of the card
+  Return Values:
+    0 -    Format was successful
+    EOF -  Format was unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSformat function can be used to create a new boot sector
+    on a device, based on the information in the master boot record.
+    This function will first initialize the I/O pins and the device,
+    and then attempts to read the master boot record.  If the MBR
+    cannot be loaded successfully, the function will fail.  Next, if
+    the 'mode' argument is specified as '0' the existing boot sector
+    information will be loaded.  If the 'mode' argument is '1' an
+    entirely new boot sector will be constructed using the disk
+    values from the master boot record.  Once the boot sector has
+    been successfully loaded/created, the locations of the FAT and
+    root will be loaded from it, and they will be completely
+    erased.  If the user has specified a volumeID parameter, a 
+    VOLUME attribute entry will be created in the root directory
+    to name the device.
+
+    FAT12, FAT16 and FAT32 formatting are supported.
+
+    Based on the number of sectors, the format function automatically
+    compute the smallest possible value for the cluster size in order to
+    accommodate the physical size of the media. In this case, if a media 
+    with a big capacity is formatted, the format function may take a very
+    long time to write all the FAT tables. 
+
+    Therefore, the FORMAT_SECTORS_PER_CLUSTER macro may be used to 
+    specify the exact cluster size (in multiples of sector size). This 
+    macro can be defined in FSconfig.h
+
+  Remarks:
+    Only devices with a sector size of 512 bytes are supported by the 
+    format function                      
+  *******************************************************************/
+
+int FSformat (char mode, long int serialNumber, char * volumeID);
+#endif
+
+
+#ifdef ALLOW_WRITES
+/***************************************************************************
+  Function:
+    int FSattrib (FSFILE * file, unsigned char attributes)
+  Summary:
+    Change the attributes of a file
+  Conditions:
+    File opened
+  Input:
+    file -        Pointer to file structure
+    attributes -  The attributes to set for the file
+               -  Attribute -      Value - Indications 
+               -  ATTR_READ_ONLY - 0x01  - The read-only attribute
+               -  ATTR_HIDDEN -    0x02  - The hidden attribute 
+               -  ATTR_SYSTEM -    0x04  - The system attribute 
+               -  ATTR_ARCHIVE -   0x20  - The archive attribute
+  Return Values:
+    0 -  Attribute change was successful 
+    -1 - Attribute change was unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSattrib funciton will set the attributes of the specified file
+    to the attributes passed in by the user.  This function will load the
+    file entry, replace the attributes with the ones specified, and write
+    the attributes back.  If the specified file is a directory, the
+    directory attribute will be preserved.
+  Remarks:
+    None                                                                
+  ***************************************************************************/
+
+int FSattrib (FSFILE * file, unsigned char attributes);
+
+
+/***************************************************************
+  Function:
+    int FSrename (const rom char * fileName, FSFILE * fo)
+  Summary:
+    Change the Ascii name of a file or directory
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file
+    fo -        The file to rename
+  Return Values:
+    0 -   File was renamed successfully
+    EOF - File was not renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrename function will rename a file.  First, it will
+    search through the current working directory to ensure the
+    specified new filename is not already in use.  If it isn't,
+    the new filename will be written to the file entry of the
+    file pointed to by 'fo.'
+  Remarks:
+    None                                                        
+  ***************************************************************/
+
+int FSrename (const char * fileName, FSFILE * fo);
+
+#ifdef SUPPORT_LFN
+/***************************************************************
+  Function:
+    int wFSrename (const rom unsigned short int * fileName, FSFILE * fo)
+  Summary:
+    Change the name of a file or directory to the UTF16 input fileName
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file
+    fo -        The file to rename
+  Return Values:
+    0 -   File was renamed successfully
+    EOF - File was not renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSrename function will rename a file.  First, it will
+    search through the current working directory to ensure the
+    specified new UTF16 filename is not already in use.  If it isn't,
+    the new filename will be written to the file entry of the
+    file pointed to by 'fo.'
+  Remarks:
+    None
+  ***************************************************************/
+
+int wFSrename (const unsigned short int * fileName, FSFILE * fo);
+#endif
+
+/*********************************************************************
+  Function:
+    int FSremove (const char * fileName)
+  Summary:
+    Delete a Ascii file
+  Conditions:
+    File not opened, file exists
+  Input:
+    fileName -  Name of the file to erase
+  Return Values:
+    0 -   File removed 
+    EOF - File was not removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSremove function will attempt to find the specified file with
+    the FILEfind function.  If the file is found, it will be erased
+    using the FILEerase function.The user can also provide ascii alias name
+    of the ascii long file name as the input to this function to get it erased
+    from the memory.
+  Remarks:
+    None                                       
+  **********************************************************************/
+
+int FSremove (const char * fileName);
+
+#ifdef SUPPORT_LFN
+/*********************************************************************
+  Function:
+    int wFSremove (const unsigned short int * fileName)
+  Summary:
+    Delete a UTF16 file
+  Conditions:
+    File not opened, file exists
+  Input:
+    fileName -  Name of the file to erase
+  Return Values:
+    0 -   File removed
+    EOF - File was not removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSremove function will attempt to find the specified UTF16 file
+    name with the FILEfind function. If the file is found, it will be erased
+    using the FILEerase function.
+  Remarks:
+    None
+  **********************************************************************/
+
+int wFSremove (const unsigned short int * fileName);
+#endif
+
+/*********************************************************************************
+  Function:
+    size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream)
+  Summary:
+    Write data to a file
+  Conditions:
+    File opened in WRITE, APPEND, WRITE+, APPEND+, READ+ mode
+  Input:
+    ptr -     Pointer to source buffer
+    size -    Size of units in bytes
+    n -       Number of units to transfer
+    stream -  Pointer to file structure
+  Return:
+    size_t - number of units written
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfwrite function will write data to a file.  First, the sector that
+    corresponds to the current position in the file will be loaded (if it hasn't
+    already been cached in the global data buffer).  Data will then be written to
+    the device from the specified buffer until the specified amount has been written.
+    If the end of a cluster is reached, the next cluster will be loaded, unless
+    the end-of-file flag for the specified file has been set.  If it has, a new
+    cluster will be allocated to the file.  Finally, the new position and filesize
+    will be stored in the FSFILE object.  The parameters 'size' and 'n' indicate how 
+    much data to write.  'Size' refers to the size of one object to write (in bytes), 
+    and 'n' will refer to the number of these objects to write.  The value returned 
+    will be equal  to 'n' unless an error occured.
+  Remarks:
+    None.
+  *********************************************************************************/
+
+size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream);
+
+#endif
+
+#ifdef ALLOW_DIRS
+
+
+/**************************************************************************
+  Function:
+    int FSchdir (char * path)
+  Summary:
+    Change the current working directory as per the path specified in Ascii format
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to.
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdir function passes a RAM pointer to the path to the
+    chdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int FSchdir (char * path);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSchdir (unsigned short int * path)
+  Summary:
+    Change the current working directory as per the path specified in UTF16 format
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to.
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdir function passes a RAM pointer to the path to the
+    chdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int wFSchdir (unsigned short int * path);
+#endif
+
+/**************************************************************
+  Function:
+    char * FSgetcwd (char * path, int numchars)
+  Summary:
+    Get the current working directory path in Ascii format
+  Conditions:
+    None
+  Input:
+    path -      Pointer to the array to return the cwd name in
+    numchars -  Number of chars in the path
+  Return Values:
+    char * - The cwd name string pointer (path or defaultArray)
+    NULL -   The current working directory name could not be loaded.
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSgetcwd function will get the name of the current
+    working directory and return it to the user.  The name
+    will be copied into the buffer pointed to by 'path,'
+    starting at the root directory and copying as many chars
+    as possible before the end of the buffer.  The buffer
+    size is indicated by the 'numchars' argument.  The first
+    thing this function will do is load the name of the current
+    working directory, if it isn't already present.  This could
+    occur if the user switched to the dotdot entry of a
+    subdirectory immediately before calling this function.  The
+    function will then copy the current working directory name 
+    into the buffer backwards, and insert a backslash character.  
+    Next, the function will continuously switch to the previous 
+    directories and copy their names backwards into the buffer
+    until it reaches the root.  If the buffer overflows, it
+    will be treated as a circular buffer, and data will be
+    copied over existing characters, starting at the beginning.
+    Once the root directory is reached, the text in the buffer
+    will be swapped, so that the buffer contains as much of the
+    current working directory name as possible, starting at the 
+    root.
+  Remarks:
+    None                                                       
+  **************************************************************/
+
+char * FSgetcwd (char * path, int numbchars);
+
+#ifdef SUPPORT_LFN
+/**************************************************************
+  Function:
+    char * wFSgetcwd (unsigned short int * path, int numchars)
+  Summary:
+    Get the current working directory path in UTF16 format
+  Conditions:
+    None
+  Input:
+    path -      Pointer to the array to return the cwd name in
+    numchars -  Number of chars in the path
+  Return Values:
+    char * - The cwd name string pointer (path or defaultArray)
+    NULL -   The current working directory name could not be loaded.
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSgetcwd function will get the name of the current
+    working directory and return it to the user.  The name
+    will be copied into the buffer pointed to by 'path,'
+    starting at the root directory and copying as many chars
+    as possible before the end of the buffer.  The buffer
+    size is indicated by the 'numchars' argument.  The first
+    thing this function will do is load the name of the current
+    working directory, if it isn't already present.  This could
+    occur if the user switched to the dotdot entry of a
+    subdirectory immediately before calling this function.  The
+    function will then copy the current working directory name 
+    into the buffer backwards, and insert a backslash character.  
+    Next, the function will continuously switch to the previous 
+    directories and copy their names backwards into the buffer
+    until it reaches the root.  If the buffer overflows, it
+    will be treated as a circular buffer, and data will be
+    copied over existing characters, starting at the beginning.
+    Once the root directory is reached, the text in the buffer
+    will be swapped, so that the buffer contains as much of the
+    current working directory name as possible, starting at the 
+    root.
+  Remarks:
+    None                                                       
+  **************************************************************/
+
+char * wFSgetcwd (unsigned short int * path, int numbchars);
+#endif
+
+#ifdef ALLOW_WRITES
+
+/**************************************************************************
+  Function:
+    int FSmkdir (char * path)
+  Summary:
+    Create a directory as per the Ascii input path
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create.
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The FSmkdir function passes a RAM pointer to the path to the
+    mkdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int FSmkdir (char * path);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSmkdir (unsigned short int * path)
+  Summary:
+    Create a directory as per the UTF16 input path
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create.
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The wFSmkdir function passes a RAM pointer to the path to the
+    mkdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int wFSmkdir (unsigned short int * path);
+#endif
+
+/**************************************************************************
+  Function:
+    int FSrmdir (char * path)
+  Summary:
+    Delete a directory as per the Ascii input path
+  Conditions:
+    None
+  Input:
+    path -      The path of the directory to remove
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrmdir function passes a RAM pointer to the path to the
+    rmdirhelper function.
+  Remarks:
+    None.
+  **************************************************************************/
+
+int FSrmdir (char * path, unsigned char rmsubdirs);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSrmdir (unsigned short int * path, unsigned char rmsubdirs)
+  Summary:
+    Delete a directory as per the UTF16 input path
+  Conditions:
+    None
+  Input:
+    path -      The path of the directory to remove
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSrmdir function passes a RAM pointer to the path to the
+    rmdirhelper function.
+  Remarks:
+    None.
+  **************************************************************************/
+
+int wFSrmdir (unsigned short int * path, unsigned char rmsubdirs);
+#endif
+
+#endif
+
+#endif
+
+#ifdef USERDEFINEDCLOCK
+
+
+/***********************************************************************************************************
+  Function:
+    int SetClockVars (unsigned int year, unsigned char month, unsigned char day, unsigned char hour, unsigned char minute, unsigned char second)
+  Summary:
+    Manually set timestamp variables
+  Conditions:
+    USERDEFINEDCLOCK macro defined in FSconfig.h.
+  Input:
+    year -     The year (1980\-2107)
+    month -   The month (1\-12)
+    day -     The day of the month (1\-31)
+    hour -    The hour (0\-23)
+    minute -  The minute (0\-59)
+    second -  The second (0\-59)
+  Return Values:
+    None
+  Side Effects:
+    Modifies global timing variables
+  Description:
+    Lets the user manually set the timing variables.  The values passed in will be converted to the format
+    used by the FAT timestamps.
+  Remarks:
+    Call this before creating a file or directory (set create time) and
+    before closing a file (set last access time, last modified time)                                        
+  ***********************************************************************************************************/
+
+int SetClockVars (unsigned int year, unsigned char month, unsigned char day, unsigned char hour, unsigned char minute, unsigned char second);
+#endif
+
+
+#ifdef ALLOW_FILESEARCH
+
+/***********************************************************************************
+  Function:
+    int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Initial search function for the input Ascii fileName
+  Conditions:
+    None
+  Input:
+    fileName - The name to search for
+             - Parital string search characters
+             - * - Indicates the rest of the filename or extension can vary (e.g. FILE.*)
+             - ? - Indicates that one character in a filename can vary (e.g. F?LE.T?T)
+    attr -            The attributes that a found file may have
+         - ATTR_READ_ONLY -  File may be read only
+         - ATTR_HIDDEN -     File may be a hidden file
+         - ATTR_SYSTEM -     File may be a system file
+         - ATTR_VOLUME -     Entry may be a volume label
+         - ATTR_DIRECTORY -  File may be a directory
+         - ATTR_ARCHIVE -    File may have archive attribute
+         - ATTR_MASK -       All attributes
+    rec -             pointer to a structure to put the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the specified criteria was found
+  Side Effects:
+    Search criteria from previous FindFirst call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent FindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The FindFirst function will search for a file based on parameters passed in
+    by the user.  This function will use the FILEfind function to parse through
+    the current working directory searching for entries that match the specified
+    parameters.  If a file is found, its parameters are copied into the SearchRec
+    structure, as are the initial parameters passed in by the user and the position
+    of the file entry in the current working directory.If the return value of the 
+    function is 0 then "utf16LFNfoundLength" indicates whether the file found was 
+    long file name or short file name(8P3 format). The "utf16LFNfoundLength" is non-zero
+    for long file name and is zero for 8P3 format."utf16LFNfound" points to the
+    address of long file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling FindNext
+  ***********************************************************************************/
+
+int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec);
+
+#ifdef SUPPORT_LFN
+/***********************************************************************************
+  Function:
+    int wFindFirst (const unsigned short int * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Initial search function for the input UTF16 fileName
+  Conditions:
+    None
+  Input:
+    fileName - The name to search for
+             - Parital string search characters
+             - * - Indicates the rest of the filename or extension can vary (e.g. FILE.*)
+             - ? - Indicates that one character in a filename can vary (e.g. F?LE.T?T)
+    attr -            The attributes that a found file may have
+         - ATTR_READ_ONLY -  File may be read only
+         - ATTR_HIDDEN -     File may be a hidden file
+         - ATTR_SYSTEM -     File may be a system file
+         - ATTR_VOLUME -     Entry may be a volume label
+         - ATTR_DIRECTORY -  File may be a directory
+         - ATTR_ARCHIVE -    File may have archive attribute
+         - ATTR_MASK -       All attributes
+    rec -             pointer to a structure to put the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the specified criteria was found
+  Side Effects:
+    Search criteria from previous wFindFirst call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent wFindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The wFindFirst function will search for a file based on parameters passed in
+    by the user.  This function will use the FILEfind function to parse through
+    the current working directory searching for entries that match the specified
+    parameters.  If a file is found, its parameters are copied into the SearchRec
+    structure, as are the initial parameters passed in by the user and the position
+    of the file entry in the current working directory.If the return value of the 
+    function is 0 then "utf16LFNfoundLength" indicates whether the file found was 
+    long file name or short file name(8P3 format). The "utf16LFNfoundLength" is non-zero
+    for long file name and is zero for 8P3 format."utf16LFNfound" points to the
+    address of long file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling FindNext
+  ***********************************************************************************/
+
+int wFindFirst (const unsigned short int * fileName, unsigned int attr, SearchRec * rec);
+#endif
+
+/**********************************************************************
+  Function:
+    int FindNext (SearchRec * rec)
+  Summary:
+    Sequential search function
+  Conditions:
+    None
+  Input:
+    rec -  The structure to store the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No additional files matching the specified criteria were found
+  Side Effects:
+    Search criteria from previous FindNext call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent FindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The FindNext function performs the same function as the FindFirst
+    funciton, except it does not copy any search parameters into the
+    SearchRec structure (only info about found files) and it begins
+    searching at the last directory entry offset at which a file was
+    found, rather than at the beginning of the current working
+    directory.If the return value of the function is 0 then "utf16LFNfoundLength"
+    indicates whether the file found was long file name or short file
+    name(8P3 format). The "utf16LFNfoundLength" is non-zero for long file name
+    and is zero for 8P3 format."utf16LFNfound" points to the address of long 
+    file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling this function
+  **********************************************************************/
+
+int FindNext (SearchRec * rec); 
+#endif
+
+
+/**********************************************************************
+  Function:
+    // PIC24/30/33/32
+    int FSfprintf (FSFILE * fptr, const char * fmt, ...)
+    // PIC18
+    int FSfpritnf (FSFILE * fptr, const rom char * fmt, ...)
+  Summary:
+    Function to write formatted strings to a file
+  Conditions:
+    For PIC18, integer promotion must be enabled in the project build
+    options menu.  File opened in a write mode.
+  Input:
+    fptr - A pointer to the file to write to.
+    fmt -  A string of characters and format specifiers to write to
+           the file
+    ... -  Additional arguments inserted in the string by format
+           specifiers
+  Returns:
+    The number of characters written to the file
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    Writes a specially formatted string to a file.
+  Remarks:
+    Consult AN1045 for a full description of how to use format
+    specifiers.        
+  **********************************************************************/
+
+#ifdef ALLOW_FSFPRINTF
+    #ifdef __18CXX
+        int FSfprintf (FSFILE *fptr, const rom char *fmt, ...);
+    #else
+        int FSfprintf (FSFILE *fptr, const char * fmt, ...);
+    #endif
+#endif
+
+
+/**************************************************************************
+  Function:
+    int FSerror (void)
+  Summary:
+    Return an error code for the last function call
+  Conditions:
+    The return value depends on the last function called.
+  Input:
+    None
+  Side Effects:
+    None.
+  Return Values:
+    FSInit       - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_INIT_ERROR ・           The physical media could not be initialized
+                 - CE_BAD_SECTOR_READ ・      The MBR or the boot sector could not be
+                                              read correctly
+                 - CE_BAD_PARITION ・         The MBR signature code was incorrect.
+                 - CE_NOT_FORMATTED ・        The boot sector signature code was incorrect or
+                                              indicates an invalid number of bytes per sector. 
+                 - CE_CARDFAT32 ・            The physical media is FAT32 type (only an error 
+                                              when FAT32 support is disabled). 
+                 - CE_UNSUPPORTED_FS ・       The device is formatted with an unsupported file 
+                                              system (not FAT12 or 16).
+    FSfopen      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_NOT_INIT ・             The device has not been initialized. 
+                 - CE_TOO_MANY_FILES_OPEN ・  The function could not allocate any 
+                                              additional file information to the array 
+                                              of FSFILE structures or the heap. 
+                 - CE_INVALID_FILENAME ・     The file name argument was invalid.
+                 - CE_INVALID_ARGUMENT ・     The user attempted to open a directory in a 
+                                              write mode or specified an invalid mode argument. 
+                 - CE_FILE_NOT_FOUND ・       The specified file (which was to be opened in read 
+                                              mode) does not exist on the device. 
+                 - CE_BADCACHEREAD ・         A read from the device failed.
+                 - CE_ERASE_FAIL ・           The existing file could not be erased (when opening 
+                                              a file in WRITE mode). 
+                 - CE_DIR_FULL ・             The directory is full. 
+                 - CE_DISK_FULL・             The data memory section is full. 
+                 - CE_WRITE_ERROR ・          A write to the device failed. 
+                 - CE_SEEK_ERROR ・           The current position in the file could not be set to 
+                                              the end (when the file was opened in APPEND mode).
+    FSfclose     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer or the new file
+                                              entry information could not be written to the device.
+                 - CE_BADCACHEREAD ・         The file entry information could not be cached
+    FSfread      - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITEONLY ・            The file was opened in a write-only mode.
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be 
+                                              written to the device. 
+                 - CE_BAD_SECTOR_READ ・      The data sector could not be read. 
+                 - CE_EOF ・                  The end of the file was reached.
+                 - CE_COULD_NOT_GET_CLUSTER ・Additional clusters in the file could not be loaded.
+    FSfwrite     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_READONLY ・             The file was opened in a read-only mode. 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected.
+                 - CE_WRITE_ERROR ・          There was an error writing data to the device.
+                 - CE_BADCACHEREAD ・         The data sector to be modified could not be read from
+                                              the device. 
+                 - CE_DISK_FULL ・            All data clusters on the device are in use.
+    FSfseek      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be
+                                              written to the device. 
+                 - CE_INVALID_ARGUMENT ・     The specified offset exceeds the size of the file. 
+                 - CE_BADCACHEREAD ・         The sector that contains the new current position 
+                                              could not be loaded.
+                 - CE_COULD_NOT_GET_CLUSTER ・Additional clusters in the file could not be 
+                                              loaded/allocated.
+    FSftell      - 
+                 - CE_GOOD ・                 No Error
+    FSattrib     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The attribute argument was invalid. 
+                 - CE_BADCACHEREAD ・         The existing file entry information could not be 
+                                              loaded. 
+                 - CE_WRITE_ERROR ・          The file entry information could not be written to 
+                                              the device.
+    FSrename     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_FILENOTOPENED ・        A null file pointer was passed into the function. 
+                 - CE_INVALID_FILENAME ・     The file name passed into the function was invalid. 
+                 - CE_BADCACHEREAD ・         A read from the device failed. 
+                 - CE_FILENAME_EXISTS ・      A file with the specified name already exists. 
+                 - CE_WRITE_ERROR ・          The new file entry data could not be written to the 
+                                              device.
+    FSfeof       -
+                 - CE_GOOD ・                 No Error
+    FSformat     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INIT_ERROR ・           The device could not be initialized. 
+                 - CE_BADCACHEREAD ・         The master boot record or boot sector could not be 
+                                              loaded successfully. 
+                 - CE_INVALID_ARGUMENT ・     The user selected to create their own boot sector on 
+                                              a device that has no master boot record, or the mode 
+                                              argument was invalid. 
+                 - CE_WRITE_ERROR ・          The updated MBR/Boot sector could not be written to 
+                                              the device.
+                 - CE_BAD_PARTITION ・        The calculated number of sectors per clusters was 
+                                              invalid. 
+                 - CE_NONSUPPORTED_SIZE ・    The card has too many sectors to be formatted as 
+                                              FAT12 or FAT16.
+    FSremove     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected. 
+                 - CE_INVALID_FILENAME ・     The specified filename was invalid. 
+                 - CE_FILE_NOT_FOUND ・       The specified file could not be found.
+                 - CE_ERASE_FAIL ・           The file could not be erased.
+    FSchdir      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The path string was mis-formed or the user tried to 
+                                              change to a non-directory file.
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached.
+                 - CE_DIR_NOT_FOUND ・        Could not find a directory in the path.
+    FSgetcwd     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The user passed a 0-length buffer into the function.
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached. 
+                 - CE_BAD_SECTOR_READ ・      The function could not determine a previous directory 
+                                              of the current working directory.
+    FSmkdir      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected. 
+                 - CE_INVALID_ARGUMENT ・     The path string was mis-formed.
+                 - CE_BADCACHEREAD ・         Could not successfully change to a recently created 
+                                              directory to store its dir entry information, or 
+                                              could not cache directory entry information. 
+                 - CE_INVALID_FILENAME ・     One or more of the directory names has an invalid 
+                                              format. 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be 
+                                              written to the device or the dot/dotdot entries could 
+                                              not be written to a newly created directory.
+                 - CE_DIR_FULL ・             There are no available dir entries in the CWD.
+                 - CE_DISK_FULL ・            There are no available clusters in the data region of 
+                                              the device.    
+    FSrmdir      - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_DIR_NOT_FOUND ・        The directory specified could not be found or the 
+                                              function could not change to a subdirectory within 
+                                              the directory to be deleted (when recursive delete is 
+                                              enabled).
+                 - CE_INVALID_ARGUMENT ・     The user tried to remove the CWD or root directory. 
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached.
+                 - CE_DIR_NOT_EMPTY ・        The directory to be deleted was not empty and 
+                                              recursive subdirectory removal was disabled. 
+                 - CE_ERASE_FAIL ・           The directory or one of the directories or files 
+                                              within it could not be deleted. 
+                 - CE_BAD_SECTOR_READ ・      The function could not determine a previous directory 
+                                              of the CWD.
+    SetClockVars -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The time values passed into the function were 
+                                              invalid.    
+    FindFirst    - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_FILENAME ・     The specified filename was invalid. 
+                 - CE_FILE_NOT_FOUND ・       No file matching the specified criteria was found. 
+                 - CE_BADCACHEREAD ・         The file information for the file that was found 
+                                              could not be cached.
+    FindNext     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_NOT_INIT ・             The SearchRec object was not initialized by a call to 
+                                              FindFirst. 
+                 - CE_INVALID_ARGUMENT ・     The SearchRec object was initialized in a different 
+                                              directory from the CWD.
+                 - CE_INVALID_FILENAME ・     The filename is invalid. 
+                 - CE_FILE_NOT_FOUND ・       No file matching the specified criteria was found.
+    FSfprintf    - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          Characters could not be written to the file.                                                   
+  Description:
+    The FSerror function will return the FSerrno variable.  This global
+    variable will have been set to an error value during the last call of a
+    library function.
+  Remarks:
+    None
+  **************************************************************************/
+
+int FSerror (void);
+
+
+/*********************************************************************************
+  Function:
+    int FSCreateMBR (unsigned long firstSector, unsigned long numSectors)
+  Summary:
+    Creates a master boot record
+  Conditions:
+    The I/O pins for the device have been initialized by the InitIO function.
+  Input:
+    firstSector -  The first sector of the partition on the device (cannot
+                   be 0; that's the MBR)
+    numSectors -   The number of sectors available in memory (including the
+                   MBR)
+  Return Values:
+    0 -   MBR was created successfully
+    EOF - MBR could not be created
+  Side Effects:
+    None
+  Description:  
+    This function can be used to create a master boot record for a device.  Note
+    that this function should not be used on a device that is already formatted
+    with a master boot record (i.e. most SD cards, CF cards, USB keys).  This
+    function will fill the global data buffer with appropriate partition information
+    for a FAT partition with a type determined by the number of sectors available
+    to the partition.  It will then write the MBR information to the first sector
+    on the device.  This function should be followed by a call to FSformat, which
+    will create a boot sector, root dir, and FAT appropriate the the information
+    contained in the new master boot record.  Note that FSformat only supports
+    FAT12 and FAT16 formatting at this time, and so cannot be used to format a
+    device with more than 0x3FFD5F sectors.
+  Remarks:
+    This function can damage the device being used, and should not be called
+    unless the user is sure about the size of the device and the first sector value.
+  *********************************************************************************/
+
+int FSCreateMBR (unsigned long firstSector, unsigned long numSectors);
+
+
+#ifdef ALLOW_GET_DISK_PROPERTIES
+/*********************************************************************************
+  Function:
+    void FSGetDiskProperties(FS_DISK_PROPERTIES* properties)
+  Summary:
+    Allows user to get the disk properties (size of disk, free space, etc)
+  Conditions:
+    1) ALLOW_GET_DISK_PROPERTIES must be defined in FSconfig.h
+    2) a FS_DISK_PROPERTIES object must be created before the function is called
+    3) the new_request member of the FS_DISK_PROPERTIES object must be set before
+        calling the function for the first time.  This will start a new search.
+    4) this function should not be called while there is a file open.  Close all
+        files before calling this function.
+  Input:
+    properties - a pointer to a FS_DISK_PROPERTIES object where the results should
+      be stored.
+  Return Values:
+    This function returns void.  The properties_status of the previous call of 
+      this function is located in the properties.status field.  This field has 
+      the following possible values:
+
+    FS_GET_PROPERTIES_NO_ERRORS - operation completed without error.  Results
+      are in the properties object passed into the function.
+    FS_GET_PROPERTIES_DISK_NOT_MOUNTED - there is no mounted disk.  Results in
+      properties object is not valid
+    FS_GET_PROPERTIES_CLUSTER_FAILURE - there was a failure trying to read a 
+      cluster from the drive.  The results in the properties object is a partial
+      result up until the point of the failure.
+    FS_GET_PROPERTIES_STILL_WORKING - the search for free sectors is still in
+      process.  Continue calling this function with the same properties pointer 
+      until either the function completes or until the partial results meets the
+      application needs.  The properties object contains the partial results of
+      the search and can be used by the application.  
+  Side Effects:
+    Can cause errors if called when files are open.  Close all files before
+    calling this function.
+
+    Calling this function without setting the new_request member on the first
+    call can result in undefined behavior and results.
+
+    Calling this function after a result is returned other than
+    FS_GET_PROPERTIES_STILL_WORKING can result in undefined behavior and results.
+  Description:  
+    This function returns the information about the mounted drive.  The results 
+    member of the properties object passed into the function is populated with 
+    the information about the drive.    
+
+    Before starting a new request, the new_request member of the properties
+    input parameter should be set to TRUE.  This will initiate a new search
+    request.
+
+    This function will return before the search is complete with partial results.
+    All of the results except the free_clusters will be correct after the first
+    call.  The free_clusters will contain the number of free clusters found up
+    until that point, thus the free_clusters result will continue to grow until
+    the entire drive is searched.  If an application only needs to know that a 
+    certain number of bytes is available and doesn't need to know the total free 
+    size, then this function can be called until the required free size is
+    verified.  To continue a search, pass a pointer to the same FS_DISK_PROPERTIES
+    object that was passed in to create the search.
+
+    A new search request sould be made once this function has returned a value 
+    other than FS_GET_PROPERTIES_STILL_WORKING.  Continuing a completed search
+    can result in undefined behavior or results.
+
+    Typical Usage:
+    <code>
+    FS_DISK_PROPERTIES disk_properties;
+
+    disk_properties.new_request = TRUE;
+
+    do
+    {
+        FSGetDiskProperties(&disk_properties);
+    } while (disk_properties.properties_status == FS_GET_PROPERTIES_STILL_WORKING);
+    </code>
+
+    results.disk_format - contains the format of the drive.  Valid results are 
+      FAT12(1), FAT16(2), or FAT32(3).
+
+    results.sector_size - the sector size of the mounted drive.  Valid values are
+      512, 1024, 2048, and 4096.
+
+    results.sectors_per_cluster - the number sectors per cluster.
+
+    results.total_clusters - the number of total clusters on the drive.  This 
+      can be used to calculate the total disk size (total_clusters * 
+      sectors_per_cluster * sector_size = total size of drive in bytes)
+
+    results.free_clusters - the number of free (unallocated) clusters on the drive.
+      This can be used to calculate the total free disk size (free_clusters * 
+      sectors_per_cluster * sector_size = total size of drive in bytes)
+
+  Remarks:
+    PIC24F size estimates:
+      Flash - 400 bytes (-Os setting)
+
+    PIC24F speed estimates:
+      Search takes approximately 7 seconds per Gigabyte of drive space.  Speed
+        will vary based on the number of sectors per cluster and the sector size.
+  *********************************************************************************/
+void FSGetDiskProperties(FS_DISK_PROPERTIES* properties);
+#endif
+
+
+#endif