Commit: 268 - kmbasic (svn)

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

Commit MetaInfo

• Revisão: 268 (tree)
• Hora: 2018-08-04 05:12:38
• Autor: kmorimatsu

Mensagem de Log

Megalopa trunk

Mudança Sumário

• added: mips/trunk/megalopa/lib_video_megalopa.h
• added: mips/trunk/megalopa/help.txt
• added: mips/trunk/megalopa/main.c
• added: mips/trunk/megalopa/io.c
• added: mips/trunk/megalopa/main.h
• added: mips/trunk/megalopa/music.c
• added: mips/trunk/megalopa/envspecific.c
• added: mips/trunk/megalopa/compiler.h
• added: mips/trunk/megalopa/function.c
• added: mips/trunk/megalopa/library.c
• added: mips/trunk/megalopa/statement.c
• added: mips/trunk/megalopa/error.c
• added: mips/trunk/megalopa/debug.h
• added: mips/trunk/megalopa/editor.c
• added: mips/trunk/megalopa/envspecific.h
• added: mips/trunk/megalopa/run.c
• added: mips/trunk/megalopa/debug.c
• added: mips/trunk/megalopa/io.h
• added: mips/trunk/megalopa/memory.c
• added: mips/trunk/megalopa/megalopa.mcp
• added: mips/trunk/megalopa/varname.c
• added: mips/trunk/megalopa/app_p32MX370F512H.ld
• added: mips/trunk/megalopa/editor.h
• added: mips/trunk/megalopa/keyinput.c
• added: mips/trunk/megalopa/exception.c
• added: mips/trunk/megalopa/globalvars.c
• added: mips/trunk/megalopa/ps2keyboard.h
• added: mips/trunk/megalopa/api.h
• added: mips/trunk/megalopa/cmpdata.c
• added: mips/trunk/megalopa/float.c
• added: mips/trunk/megalopa/string.c
• added: mips/trunk/megalopa/value.c
• added: mips/trunk/megalopa/compiler.c
• added: mips/trunk/megalopa/file.c
• added: mips/trunk/megalopa/keyinput.h
• added: mips/trunk/megalopa/linker.c
• added: mips/trunk/megalopa/operator.c
• added: mips/trunk/megalopa/sdfsio370f.h
• added: mips/trunk/megalopa

Diff

--- mips/trunk/megalopa/lib_video_megalopa.h	(nonexistent)
+++ mips/trunk/megalopa/lib_video_megalopa.h	(revision 268)
@@ -0,0 +1,140 @@
+// lib_video_megalopa.h
+// テキスト＋グラフィックビデオ出力　PIC32MX370F512H用ヘッダーファイル　by K.Tanaka
+
+#define X_RES	288 // Graphic横方向解像度
+#define X_RESW	384 // Graphic横方向解像度（ワイド時）
+#define X_RESZ	256 // Graphic横方向解像度（type Z互換時）
+#define Y_RES	216 // Graphic縦方向解像度
+#define Y_RESZ	224 // Graphic縦方向解像度（type Z互換時）
+#define WIDTH_X	36 // 横方向文字数
+#define WIDTH_Y	27 // 縦方向文字数
+#define WIDTH_XW	48 // 横方向文字数（ワイド時）
+#define WIDTH_XW2	64 // 横方向文字数（ワイド、6ドットフォント時）
+#define WIDTH_XBW	80 // 横方向文字数（モノクロ時）
+#define WIDTH_30	30 // 横方向文字数（互換モード8ドットフォント時）
+#define WIDTH_40	40 // 横方向文字数（互換モード6ドットフォント時）
+#define ATTROFFSET	(WIDTH_X*WIDTH_Y) // TVRAM上のカラーパレット格納位置（標準時）
+#define ATTROFFSETW	(WIDTH_XW*WIDTH_Y) // TVRAM上のカラーパレット格納位置（ワイド時）
+#define ATTROFFSETW2	(WIDTH_XW2*WIDTH_Y) // TVRAM上のカラーパレット格納位置（ワイド、6ドットフォント時）
+#define ATTROFFSETBW	(WIDTH_XBW*WIDTH_Y) // TVRAM上のカラーパレット格納位置（モノクロ時）
+#define ATTROFFSET30	(WIDTH_30*WIDTH_Y) // TVRAM上のカラーパレット格納位置（互換モード8ドットフォント時）
+#define ATTROFFSET40	(WIDTH_40*WIDTH_Y) // TVRAM上のカラーパレット格納位置（互換モード6ドットフォント時）
+#define WIDTH_XMAX WIDTH_XBW // 横方向最大文字数
+
+// videomode値
+#define VMODE_T30 0 // 標準テキスト30文字互換モード
+#define VMODE_STDTEXT 1 // 標準テキスト36文字モード
+#define VMODE_T40 2 // 標準テキスト40文字互換モード（6ドットフォント）
+#define VMODE_WIDETEXT 3 // ワイドテキスト48文字モード
+#define VMODE_WIDETEXT6dot 4 // ワイドテキスト64文字モード（6ドットフォント）
+#define VMODE_MONOTEXT 5 // モノクロテキスト80文字モード
+#define VMODE_ZOEAGRPH 16 // type Z互換グラフィックモード
+#define VMODE_STDGRPH 17 // 標準グラフィック＋テキスト36文字モード
+#define VMODE_WIDEGRPH 18 // ワイドグラフィック＋テキスト48文字モード
+
+// textomode値
+#define TMODE_T30 0 // 標準テキスト30文字互換モード
+#define TMODE_STDTEXT 1 // 標準テキスト36文字モード
+#define TMODE_T40 2 // 標準テキスト40文字互換モード（6ドットフォント）
+#define TMODE_WIDETEXT 3 // ワイドテキスト48文字モード
+#define TMODE_WIDETEXT6dot 4 // ワイドテキスト64文字モード（6ドットフォント）
+#define TMODE_MONOTEXT 5 // モノクロテキスト80文字モード
+
+// graphmode値
+#define GMODE_NOGRPH 0 // グラフィック不使用
+#define GMODE_ZOEAGRPH 1 // type Z互換グラフィックモード
+#define GMODE_STDGRPH 2 // 標準グラフィック＋テキスト36文字モード
+#define GMODE_WIDEGRPH 3 // ワイドグラフィック＋テキスト48文字モード
+
+#define KEYPORT PORTD
+#define KEYUP 0x0004
+#define KEYDOWN 0x0001
+#define KEYLEFT 0x0002
+#define KEYRIGHT 0x0008
+#define KEYSTART 0x0010
+#define KEYFIRE 0x0020
+
+extern volatile char drawing;		//　表示期間中は-1
+extern volatile unsigned short drawcount;		//　1画面表示終了ごとに1足す。アプリ側で0にする。
+							// 最低1回は画面表示したことのチェックと、アプリの処理が何画面期間必要かの確認に利用。
+extern unsigned char *GVRAM; // Graphicビデオメモリ
+extern unsigned char TVRAM[]; // Characterビデオメモリ
+extern const unsigned char FontData[]; //フォントパターン(初期化時にここからfontdata[]にコピー)
+extern const unsigned char FontData2[]; //フォントパターン6ドットフォント
+extern unsigned char videomode,textmode,graphmode; //画面モード
+extern int twidth,twidthy; //テキスト文字数（横）および（縦
+extern int attroffset; // TVRAMのカラー情報エリア位置
+extern int gwidth,gwidthy; // グラフィックX方向解像度
+extern unsigned char fontdata[]; //固定フォント領域、初期化時にFontData[]からコピー
+extern unsigned char *Fontp; //現在のフォントパターンの先頭アドレス
+
+void start_composite(void); //カラーコンポジット出力開始
+void stop_composite(void); //カラーコンポジット出力停止
+void init_composite(void); //カラーコンポジット出力初期化
+void init_palette(void); //カラーパレット初期化
+void g_clearscreen(void); //Graphic画面クリア
+void clearscreen(void); //Character画面クリア
+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_videomode(unsigned char m, unsigned char *gvram); //ビデオモードの切り替え
+
+// 以下は text_graph_library.c ライブラリを使用するための宣言
+
+// グラフィック画面関連
+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)の水平ラインをカラーcで高速描画
+void g_boxfill(int x1,int y1,int x2,int y2,unsigned int c);
+	//座標(x1,y1),(x2,y2)を対角線とするカラーcで塗られた長方形を描画
+	// (x1,y1),(x2,y2)を対角線とするカラーcで塗られた長方形を描画
+void g_circle(int x0,int y0,unsigned int r,unsigned int c);
+	// (x0,y0)を中心に、半径r、カラー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を返す
+
+//テキスト画面関連
+extern unsigned char *cursor;
+extern unsigned char cursorcolor;
+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);
+	//テキスト画面を0でクリアし、カーソルを画面先頭に移動
+void startPCG(unsigned char *p,int a);
+	// RAMフォント（PCG）の利用開始、pがフォント格納場所、aが0以外でシステムフォントをコピー
+void stopPCG(void);
+	// RAMフォント（PCG）の利用停止

Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

--- mips/trunk/megalopa/help.txt	(nonexistent)
+++ mips/trunk/megalopa/help.txt	(revision 268)

Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property

--- mips/trunk/megalopa/main.c	(nonexistent)
+++ mips/trunk/megalopa/main.c	(revision 268)
@@ -0,0 +1,360 @@
+/*
+   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 Megalopa
+// KM-BASIC 統合開発実行環境 for PIC32MX370F512H by K.Tanaka
+
+// 利用システム
+// ps2keyboard370f.X.a : PS/2キーボード入力システムライブラリ
+// lib_videoout_megalopa.X.a : カラービデオ信号出力システムライブラリ
+// sdfsio370fLib.a ： SDカードアクセス用ライブラリ
+
+
+/*
+	PIC32MX ペリフェラル使用状況
+	
+	割り込み
+		NTSC,   Timer2, vector  8, priority 5
+		NTSC,   OC5,    vector 22, priority 5
+		NTSC,   OC2,    vector 10, priority 5
+		NTSC,   OC1,    vector  6, priority 5
+		PS/2,   CNF,    vector 33, priority 6
+		PS/2,   Timer5, vector 20, priority 4
+		MUSIC,  CS0,    vector  1, priority 2
+		SERIAL, UART,   vector 31, priority 3
+	
+	タイマー
+		Timer1 未使用
+		Timer2 NTSC
+		Timer3 MUSIC/PWM
+		Timer4 MUSIC
+		Timer5 PS/2
+	
+	DMA
+		DMA0 未使用
+		DMA1 MUSIC
+		DMA2 MUSIC
+		DMA3 PS/2
+	
+	Output compair
+		OC1 NTSC
+		OC2 NTSC
+		OC3 MUSIC/PWM
+		OC4 MUSIC/PWM
+		OC5 NTSC
+	
+	UART
+		UART1 シリアル通信
+		UART2 未使用
+	
+	SPI
+		SPI1 SPI通信（予定）
+		SPI2 マルチメディアカード
+	
+	I2C
+		I2C1 I2C通信（予定）
+		I2C2 未使用
+	
+	ポート使用
+		B0  I/O, AN0
+		B1  I/O, AN1
+		B2  I/O, AN2
+		B3  I/O, AN3
+		B4  I/O, AN4
+		B5  I/O, AN5
+		B6  I/O, AN6
+		B7  I/O, AN7
+		B8  I/O, AN8
+		B9  I/O, AN9
+		B10 I/O, AN10
+		B11 I/O, AN11
+		B12 I/O, AN12
+		B13 I/O, AN13
+		B14 I/O, AN14
+		B15 I/O, AN15
+		C12 OSC1 (Crystal)
+		C13 U1TX (UART)
+		C14 U1RX (UART)
+		C15 OSC2 (Crystal)
+		D0  SW_DOWN
+		D1  SW_LEFT
+		D2  SW_UP
+		D3  SW_RIGHT
+		D4  SW_START
+		D5  SW_FIRE
+		D6  
+		D7  
+		D8  
+		D9  SPI1_CS (SPI)
+		D10 PWM1
+		D11 PWM2
+		E0  NTSC
+		E1  NTSC
+		E2  NTSC
+		E3  NTSC
+		E4  NTSC
+		E5  I/O, AN22
+		E6  I/O, AN23
+		E7  I/O, AN27
+		F0  PS/2 DAT
+		F1  PS/2 CLK
+		F2  SDI1 (SPI)
+		F3  SPI2_CS (MMC)
+		F4  AUDIO_R
+		F5  AUDIO_L
+		F6  SCK1 (SPI)
+		G2  SCL1 (I2C)
+		G3  SDA1 (I2C)
+		G6  SCK2 (MMC)
+		G7  SDI2 (MMC)
+		G8  SDO2 (MMC)
+		G9  SDO1 (SPI)
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+#include "editor.h"
+#include "keyinput.h"
+#include "main.h"
+
+//外付けクリスタル with PLL (20/3倍)
+//クリスタルは3.579545×4＝14.31818MHz
+#pragma config FSRSSEL = PRIORITY_7
+#pragma config PMDL1WAY = OFF
+#pragma config IOL1WAY = OFF
+//#pragma config FUSBIDIO = OFF
+//#pragma config FVBUSONIO = OFF
+#pragma config FPLLIDIV = DIV_3
+#pragma config FPLLMUL = MUL_20
+//#pragma config UPLLIDIV = DIV_1
+//#pragma config UPLLEN = OFF
+#pragma config FPLLODIV = DIV_1
+#pragma config FNOSC = PRIPLL
+#pragma config FSOSCEN = OFF
+#pragma config IESO = OFF
+#pragma config POSCMOD = XT
+#pragma config OSCIOFNC = OFF
+#pragma config FPBDIV = DIV_1
+#pragma config FCKSM = CSDCMD
+#pragma config FWDTEN = OFF
+#pragma config DEBUG = OFF
+#pragma config PWP = OFF
+#pragma config BWP = OFF
+#pragma config CP = OFF
+
+#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","WIDTH36","WIDTH48","WIDTH80"
+};
+unsigned char initialvmode;
+
+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;
+			case 5:
+				initialvmode=VMODE_STDTEXT;
+				break;
+			case 6:
+				initialvmode=VMODE_WIDETEXT;
+				break;
+			case 7:
+				initialvmode=VMODE_MONOTEXT;
+				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;
+
+	/* ポートの初期設定 */
+	CNPUB = 0xFFFF; // PORTB全てプルアップ(I/O)
+	TRISB = 0xFFFF; // PORTB全て入力
+	CNPUC = 0x4000; // PORTC14プルアップ(U1RX)
+	TRISC = 0x4000; // PORTC14以外は出力
+	TRISD = KEYSTART | KEYFIRE | KEYUP | KEYDOWN | KEYLEFT | KEYRIGHT;// ボタン接続ポート入力設定
+	CNPUE = 0x00E0; // PORTE5-7プルアップ(I/O)
+	TRISE = 0x00E0; // PORTE0-4出力5-7入力
+	CNPUF = 0x0004; // PORTF2プルアップ(SDI1)
+	TRISF = 0x0004; // PORTF2以外は出力
+	TRISG = 0x0080; // PORTG7以外は出力
+
+	ANSELB = 0x0000; // 全てデジタル
+	ANSELD = 0x0000; // 全てデジタル
+	ANSELE = 0x0000; // 全てデジタル
+	ANSELG = 0x0000; // 全てデジタル
+	CNPUDSET=KEYSTART | KEYFIRE | KEYUP | KEYDOWN | KEYLEFT | KEYRIGHT;// プルアップ設定
+	ODCF = 0x0003;	//RF0,RF1はオープンドレイン
+
+	// 周辺機能ピン割り当て
+	SDI2R = 1; //RPG7にSDI2を割り当て
+	RPG8R = 6; //RPG8にSDO2を割り当て
+
+	// Make RAM executable. See also "char RAM[RAMSIZE]" in globalvars.c
+	mBMXSetRAMKernProgOffset(PIC32MX_RAMSIZE-RAMSIZE);
+	mBMXSetRAMUserDataOffset(PIC32MX_RAMSIZE);
+	mBMXSetRAMUserProgOffset(PIC32MX_RAMSIZE);
+
+	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");
+
+	// 音源初期化
+	OC4RS=LATFbits.LATF5 ? 0xff:0x00;
+	OC3RS=LATFbits.LATF4 ? 0xff:0x00;
+	init_music();
+
+	initialvmode=VMODE_STDTEXT; // 標準テキストモード（36文字）
+	lockkey=2; // NumLockキーオン
+	keytype=0; // 日本語キーボード
+	readinifile(); //INIファイル読み込み
+	printstr("Init PS/2...");
+	wait60thsec(30); //0.5秒待ち
+	if(ps2init()){ //PS/2初期化
+		//キーボードが見つからない場合
+		printstr("Keyboard Not Found\n");
+	}
+	else printstr("OK\n");
+
+	wait60thsec(60); //1秒待ち
+
+	set_videomode(initialvmode,0); //ビデオモード切替
+
+	// 実行中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/trunk/megalopa/io.c	(nonexistent)
+++ mips/trunk/megalopa/io.c	(revision 268)
@@ -0,0 +1,651 @@
+/*
+   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 "compiler.h"
+
+/*
+	Library functions follow
+*/
+static short* g_serial_buff=0;
+static int g_serial_buff_read_pos,g_serial_buff_write_pos;
+static int g_serial_buff_size;
+void lib_serial(int baud, int parity, int bsize){
+	// SERIAL x[,y[,z]]
+	// where x is baud rate. If zero, stop using it.
+	// y (0 is default) is parity setting; 0: 8 bit no parity, 
+	// 1: 8 bit even parity, 2: 8 bit odd parity, 3: 9 bit no parity
+	// z is input buffer size. If z=0 (default), the size will be calculated automatically.
+	// Calculation is: z=BAUD/10/60/2*3 (z=BAUD/400), which is 1.5 times more size required for 1/60 sec.
+	/*
+		RC13 U1TX RC14 U1RX 
+		U1MODE=0x0000 | (parity<<1)
+		U1MODEbits.ON=0;
+		U1MODEbits.FRZ=0;     Continue operation when CPU is in Debug Exception mode;
+		U1MODEbits.SIDL=0;    Continue operation in Idle mode
+		U1MODEbits.IREN=0;    IrDA is disabled;
+		U1MODEbits.RTSMD=0;   UxRTS pin is in Flow Control mode
+		U1MODEbits.UEN=0;     Only UxTX and UxRX pins are enabled and used;
+		U1MODEbits.WAKE=0;    Wake-up disabled
+		U1MODEbits.LPBACK=0;  Loopback mode is disabled
+		U1MODEbits.ABAUD=0;   Baud rate measurement disabled or completed
+		U1MODEbits.RXINV=0;   UxRX Idle state is ‘1’
+		U1MODEbits.BRGH=0;    Standard Speed mode ? 16x baud clock enabled
+		U1MODEbits.PDSEL=0-3;
+		U1MODEbits.STSEL=0;   1 Stop bit
+		U1STA=0x00001400;
+		U1STAbits.ADM_EN=0;   Automatic Address Detect mode is disabled
+		U1STAbits.ADDR=0;     Don't care
+		U1STAbits.UTXISEL=0;  Don't care. Don't use TX interrupt
+		U1STAbits.UTXINV=0;   UxTX Idle state is ‘1’
+		U1STAbits.URXEN=1;    UARTx receiver is enabled. UxRX pin is controlled by UARTx (if ON = 1)
+		U1STAbits.UTXBRK=0;   Break transmission is disabled or completed
+		U1STAbits.UTXEN=1;    UARTx transmitter is enabled. UxTX pin is controlled by UARTx (if ON = 1)
+		U1STAbits.URXISEL=0;  Interrupt flag bit is set when a character is received
+		U1STAbits.ADDEN=0;    Address Detect mode is disabled
+		U1STAbits.OERR=0;     Receive buffer has not overflowed
+		U1BRG=FPB/16/baud - 1
+	*/
+	if (baud==0) {
+		// Disable UART
+		U1MODE=0x0000;
+		U1STA=0x00000000;
+		IEC1bits.U1TXIE=0;
+		IEC1bits.U1RXIE=0;
+		// Free buffer area
+		if (g_serial_buff) free_temp_str((char*)g_serial_buff);
+		g_serial_buff=0;
+	} else {
+		// Prepare buffer for SERIALIN
+		if (bsize==0) bsize=baud/400; // Area corresponds to ~1/40 sec (> 1/60 sec)
+		g_serial_buff_size=bsize;
+		if (g_serial_buff) free_temp_str((char*)g_serial_buff);
+		g_serial_buff=(short*)alloc_memory((bsize+1)/2,get_permanent_var_num());
+		g_serial_buff_read_pos=g_serial_buff_write_pos=0;
+		// Initialize I/O ports
+		TRISCSET=1<<14;  // Input from RC14
+		ANSELCCLR=1<<14; // Digital for RC14
+		U1RXR=7;         // Use RC14 for U1RX
+		TRISCCLR=1<<13;  // Output to RC13
+		RPC13R=3;        // Use RC13 for U1TX
+		// Initialize UART
+		U1MODE=0x0000 | ((parity&3)<<1);
+		U1STA=0x00001400;
+		U1BRG=95454533/16/baud -1;
+		// Interrupt settings. Use only RX interrupt.
+		IEC1bits.U1TXIE=0;
+		IFS1bits.U1RXIF=0;
+		IEC1bits.U1RXIE=1;
+		IPC7bits.U1IP=3;
+		IPC7bits.U1IS=0;
+		// Start UART
+		U1MODEbits.ON=1;
+	}
+}
+#pragma interrupt uartint IPL3SOFT vector 31
+void uartint(){
+	int err;
+	IFS1bits.U1RXIF=0;
+	while(U1STAbits.URXDA){
+		// Fill into the buffer while RX data is available
+		err=0;
+		if (U1STAbits.PERR) {
+			if (U1MODEbits.PDSEL==1 || U1MODEbits.PDSEL==2) {
+				// Parity error
+				err=0x100;
+			}
+		}
+		g_serial_buff[g_serial_buff_write_pos]=err|U1RXREG;
+		g_serial_buff_write_pos++;
+		if (g_serial_buff_size<=g_serial_buff_write_pos) g_serial_buff_write_pos=0;
+	}
+}
+
+void lib_serialout(int data){
+	// SERIALOUT x
+	// where x is 8 bit data. If FIFO buffer is full, wait until ready.
+	if (U1MODEbits.PDSEL==3) {
+		// 9 bit
+		data&=0x1ff;
+	} else {
+		data&=0xff;
+	}
+	// Wait while buffer is full
+	while(U1STAbits.UTXBF){
+		asm("nop");
+	}
+	// Send data.
+	U1TXREG=data;
+}
+int lib_serialin(int mode){
+	int i;
+	// SERIALIN([x])
+	// x=0 (default): return data. If no data remaining, return -1.
+	// x=1: If data exist(s) return 1, if not, return 0.
+	switch(mode){
+		case 1:
+			// Return # of data in buffer
+			i=g_serial_buff_write_pos-g_serial_buff_read_pos;
+			if (i<0) i+=g_serial_buff_size;
+			return i;
+		case 0:
+		default:
+			if (g_serial_buff_write_pos==g_serial_buff_read_pos) return -1;
+			i=g_serial_buff[g_serial_buff_read_pos];
+			g_serial_buff_read_pos++;
+			if (g_serial_buff_size<=g_serial_buff_read_pos) g_serial_buff_read_pos=0;
+			return i;
+	}
+}
+
+void lib_pwm(int duty, int freq, int num){
+	/*
+		OCxCON=0x000D;
+		OCxCONbits.ON=0;
+		OCxCONbits.SIDL=0;   // Continue operation in Idle mode
+		OCxCONbits.OC32=0;   // OCxR<15:0> and OCxRS<15:0> are used for comparisons to the 16-bit timer source
+		OCxCONbits.OCFLT;    // Not used
+		OCxCONbits.OCTSEL=1; // Timer3 is the clock source for this Output Compare module
+		OCxCONbits.OCM=5;    // Initialize OCx pin low; generate continuous output pulses on OCx pin
+
+		Signal will be L when TMR3 reaches OCxRS, and H when TMR3 reaches OCxR
+
+		Timer3 prescaler: 1, 2, 4, 8, 16, 32, 64, 256
+		For slowest Timer3 (PR3=65535), in Hz: 1456.5, 728.3, 364.1, 182.1, 91.0, 45.5, 22.8, 5.69
+		For fastest Timer3 (PR3=1000), in Hz: 95455, 47727, 23864, 11932, 5966, 2983, 1492, 373
+		Therefore, for freq value,
+			6-22:       1/256 prescaler
+			23-45:      1/64
+			46-91:      1/32
+			92-182:     1/16
+			183-364:    1/8
+			365-728:    1/4
+			729-1456:   1/2
+			1457-95455: 1/1
+
+	*/
+	static int prevfreq=0, prevPR3=0;
+	if (num==0) {
+		// Reset PWM
+		prevfreq=prevPR3=0;
+		return;
+	}
+	if (duty==0) {
+		// Continuous output of L signal
+		switch(num){
+			case 1:
+				// Use RD10 for digital output
+				LATDCLR=1<<10;
+				RPD10R=0;
+				TRISDCLR=1<<10;
+				return;
+			case 2:
+				// Use RD11 for digital output
+				LATDCLR=1<<11;
+				RPD11R=0;
+				TRISDCLR=1<<11;
+				return;
+			default:
+				err_invalid_param();
+		}
+	} else if (duty==1000) {
+		// Continuous output of H signal
+		switch(num){
+			case 1:
+				// Use RD10 for digital output
+				LATDSET=1<<10;
+				RPD10R=0;
+				TRISDCLR=1<<10;
+				return;
+			case 2:
+				// Use RD11 for digital output
+				LATDSET=1<<11;
+				RPD11R=0;
+				TRISDCLR=1<<11;
+				return;
+			default:
+				err_invalid_param();
+		}
+	}
+	// PWM mode
+	if (freq!=prevfreq || PR3!=prevPR3) {
+		// Initialize PWM system
+		OC3CON=0x0000;
+		OC4CON=0x0000;
+		IEC0bits.OC3IE=0;
+		IEC0bits.OC4IE=0;
+		// Stop music
+		stop_music();
+		// Initialize timer 3
+		IEC0bits.T3IE=0;
+		if (freq<6) {
+			err_invalid_param();
+		} else if (freq<23) {
+			// 1/256 prescaler
+			T3CON=0x0070;
+			prevPR3=(int)((95454533/256)/freq)-1;
+		} else if (freq<46) {
+			// 1/64 prescaler
+			T3CON=0x0060;
+			prevPR3=(int)((95454533/64)/freq)-1;
+		} else if (freq<92) {
+			// 1/32 prescaler
+			T3CON=0x0050;
+			prevPR3=(int)((95454533/32)/freq)-1;
+		} else if (freq<183) {
+			// 1/16 prescaler
+			T3CON=0x0040;
+			prevPR3=(int)((95454533/16)/freq)-1;
+		} else if (freq<365) {
+			// 1/8 prescaler
+			T3CON=0x0030;
+			prevPR3=(int)((95454533/8)/freq)-1;
+		} else if (freq<729) {
+			// 1/4 prescaler
+			T3CON=0x0020;
+			prevPR3=(int)((95454533/4)/freq)-1;
+		} else if (freq<1457) {
+			// 1/2 prescaler
+			T3CON=0x0010;
+			prevPR3=(int)((95454533/2)/freq)-1;
+		} else if (freq<95455) {
+			// 1/1 prescaler
+			T3CON=0x0000;
+			prevPR3=(int)(95454533/freq)-1;
+		} else {
+			err_invalid_param();
+		}
+		TMR3=0;
+		PR3=prevPR3;
+		prevfreq=freq;
+	}
+	// Wait until Timer3 will reset
+	if (T3CONbits.ON) {
+		IFS0bits.T3IF=0;
+		while (IFS0bits.T3IF==0); 
+	};
+	// Stop and reset timer
+	T3CONCLR=0x8000;
+	TMR3=PR3;
+	// New PWM setting follows
+	switch(num){
+		case 1:
+			// Use OC3/RD10
+			RPD10R=11;
+			TRISDCLR=1<<10;
+			// Disable OC3 first
+			OC3CON=0x0000;
+			// OC3 settings
+			OC3CON=0x000D;
+			OC3R=0;
+			OC3RS=(((int)PR3+1)*duty) / 1000;
+			// Start OC3 and timer
+			OC3CONSET=0x8000;
+			T3CONSET=0x8000;
+			break;
+		case 2:
+			// Use OC4/RD11
+			RPD11R=11;
+			TRISDCLR=1<<11;
+			// Disable OC4 first
+			OC4CON=0x0000;
+			// OC4 settings
+			OC4CON=0x000D;
+			OC4R=0;
+			OC4RS=(((int)PR3+1)*duty) / 1000;
+			// Wait until Timer3 will reset
+			if (T3CONbits.ON) {
+				IFS0bits.T3IF=0;
+				while (IFS0bits.T3IF==0); 
+			};
+			// Start OC4 and timer
+			OC4CONSET=0x8000;
+			T3CONSET=0x8000;
+			break;
+		default:
+			err_invalid_param();
+	}
+}
+
+void lib_out(int pos, int val){
+	// pos must be between 0 and 15 or 16 and 18
+	if (0<=pos && pos<=15) {
+		// PORTB0-15
+		// Set output vale
+		if (val) {
+			LATBSET=1<<pos;
+		} else {
+			LATBCLR=1<<pos;
+		}
+		// Enable output
+		TRISBCLR=1<<pos;
+		// Disable pulldown
+		CNPUBCLR=1<<pos;
+	} else if (16<=pos && pos<=18) {
+		// PORTE5-7, open drain
+		pos=pos-16+5;
+		// Set output vale (L)
+		LATECLR=1<<pos;
+		// Output for L and input for H
+		if (val) {
+			// Disable output
+			TRISESET=1<<pos;
+		} else {
+			// Enable output
+			TRISECLR=1<<pos;
+		}
+	} else {
+		return;
+	}
+}
+
+void lib_out8h(int val){
+	// Set output vale
+	LATB=(LATB&0x00FF)|((val&0xff)<<8);
+	// Enable output
+	TRISBCLR=0xFF00;
+	// Disable pulldown
+	CNPUBCLR=0xFF00;
+}
+
+void lib_out8l(int val){
+	// Set output vale
+	LATB=(LATB&0xFF00)|(val&0xff);
+	// Enable output
+	TRISBCLR=0x00FF;
+	// Disable pulldown
+	CNPUBCLR=0x00FF;
+}
+
+int lib_out16(int val){
+	// Set output vale
+	LATB=(val&0xFFFF);
+	// Enable output
+	TRISBCLR=0xFFFF;
+	// Disable pulldown
+	CNPUBCLR=0xFFFF;
+}
+
+int lib_in(int pos){
+	// pos must be between 0 and 15 or 16 and 18
+	if (0<=pos && pos<=15) {
+		// PORTB0-15
+		// Enable pulldown
+		CNPUBSET=1<<pos;
+		// Enable input
+		TRISBSET=1<<pos;
+		ANSELBCLR=1<<pos;
+		// Read value and return
+		return (PORTB&(1<<pos)) ? 1:0;
+	} else if (16<=pos && pos<=18) {
+		// PORTE5-7
+		pos=pos-16+5;
+		// Enable pulldown
+		CNPUESET=1<<pos;
+		// Enable input
+		TRISESET=1<<pos;
+		ANSELECLR=1<<pos;
+		// Read value and return
+		return (PORTE&(1<<pos)) ? 1:0;
+	} else {
+		return 0;
+	}
+}
+
+int lib_in8h(){
+	// Enable pulldown
+	CNPUBSET=0xFF00;
+	// Enable input
+	TRISBSET=0xFF00;
+	ANSELBCLR=0xFF00;
+	// Read value and return
+	return (PORTB&0xFF00)>>8;
+}
+
+int lib_in8l(){
+	// Enable pulldown
+	CNPUBSET=0x00FF;
+	// Enable input
+	TRISBSET=0x00FF;
+	ANSELBCLR=0x00FF;
+	// Read value and return
+	return PORTB&0x00FF;
+}
+
+int lib_in16(){
+	// Enable pulldown
+	CNPUBSET=0xFFFF;
+	// Enable input
+	TRISBSET=0xFFFF;
+	ANSELBCLR=0xFFFF;
+	// Read value and return
+	return PORTB&0xFFFF;
+}
+
+int lib_analog(int pos){
+	/*
+		Analog to 12 bit digital converter function.
+		AD1CON1=0x00E0;
+		AD1CON1bits.ON=0;
+		AD1CON1bits.SIDL=0;    // Continue module operation in Idle mode
+		AD1CON1bits.FORM=0;    // Integer 16-bit
+		AD1CON1bits.SSRC=8;    // Internal counter ends sampling and starts conversion (auto convert)
+		AD1CON1bits.CLRASAM=0; // Normal operation, buffer contents will be overwritten by the next conversion sequence
+		AD1CON1bits.ASAM=0;    // Sampling begins when SAMP bit is set.
+		AD1CON1bits.SAMP=0;    // The ADC sample/hold amplifier is holding
+		AD1CON1bits.DONE=0;    // Analog-to-digital conversion is not done or has not started
+		AD1CON2=0;
+		AD1CON2bits.VCFG=0;   // Voltage reference:AVdd-AVss
+		AD1CON2bits.OFFCAL=0; // Disable Offset Calibration mode
+		AD1CON2bits.CSCNA=0;  // Do not scan inputs
+		AD1CON2bits.BUFS=0;   // Do not care, only valid when BUFM=1
+		AD1CON2bits.SMPI=0;   // Do not care. Do not use interrupt.
+		AD1CON2bits.BUFM=0;   // Buffer configured as one 16-word buffer ADC1BUFF-ADC1BUF0
+		AD1CON2bits.ALTS=0;   // Always use Sample A input multiplexer settings
+		AD1CON3=0x0607;
+		AD1CON3bits.ADRC=0; // Clock derived from Peripheral Bus Clock (PBCLK)
+		AD1CON3bits.SAMC=6; // Auto-Sample Time: 6 TAD = 1005.72 ns (> 1000 ns)
+		AD1CON3bits.ADCS=7; // TAD=TPB*2*8=167.62 ns (> 154 ns)
+		AD1CHS=(0-27)<<16;
+		AD1CHSbits.CN0NB=0;    // Do not care, only valid when using channel B
+		AD1CHSbits.CH0SB=0;    // Do not care, only valid when using channel B
+		AD1CHSbits.CH0NA=0;    // Channel 0 negative input is VREFL
+		AD1CHSbits.CH0SA=0-27; // Set input channel here
+		AD1CSSL; // Do not care, only valid when CSCNA=1;
+	*/
+	AD1CON1=0x00E0;
+	AD1CON2=0x0000;
+	AD1CON3=0x0607;
+	// pos must be between 0 and 15 or 16 and 18
+	if (0<=pos && pos<=15) {
+		// RB0-RB15: AN0-AN15
+		// Disable pulldown
+		CNPUBCLR=1<<pos;
+		// Enable input
+		TRISBSET=1<<pos;
+		// Enable analog
+		ANSELBSET=1<<pos;
+		// Select input pin
+		AD1CHS=pos<<16;
+	} else if (16<=pos && pos<=18) {
+		// RE5,6,7:AN22,23,27
+		pos=pos-16+5;
+		// Disable pulldown
+		CNPUECLR=1<<pos;
+		// Enable input
+		TRISESET=1<<pos;
+		// Enable analog
+		ANSELESET=1<<pos;
+		// Select input pin
+		if (pos<=6) {
+			pos=pos-5+22;
+		} else {
+			pos=pos-7+27;
+		}
+		AD1CHS=pos<<16;
+	} else {
+			err_invalid_param();
+	}
+	// Enable ADC
+	AD1CON1bits.ON=1;
+	// Start 
+	AD1CON1bits.SAMP=1;
+	// Wait until done
+	while(!AD1CON1bits.DONE){
+		asm("nop");
+	}
+	// Disable ADC
+	AD1CON1bits.ON=0;
+	// Return value
+	return ADC1BUF0;
+}
+
+/*
+	Statements and functions implementations follow
+*/
+
+// Local prototyping
+char* param2_statement(enum libs lib);
+
+char* out_statement(){
+	return param2_statement(LIB_SYSTEM | EXTRA_OUT);
+}
+char* out8h_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_OUT8H);
+	return 0;
+}
+char* out8l_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_OUT8L);
+	return 0;
+}
+char* out16_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_OUT16);
+	return 0;
+}
+char* pwm_statement(){
+	char* err;
+	// Get 1st parameter
+	err=get_value();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd parameter
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x340203E8; //ori         v0,zero,1000
+	}
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd parameter
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020001; //ori         v0,zero,1
+	}
+	// Insert calling system code
+	call_lib_code(LIB_SYSTEM | EXTRA_PWM);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+char* in_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_IN);
+	return 0;
+}
+char* in8h_function(){
+	call_lib_code(LIB_SYSTEM | EXTRA_IN8H);
+	return 0;
+}
+char* in8l_function(){
+	call_lib_code(LIB_SYSTEM | EXTRA_IN8L);
+	return 0;
+}
+char* in16_function(){
+	call_lib_code(LIB_SYSTEM | EXTRA_IN16);
+	return 0;
+}
+char* analog_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_ANALOG);
+	return 0;
+}
+char* serial_statement(){
+	char* err;
+	// Get 1st parameter
+	err=get_value();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd parameter
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; //ori         v0,zero,0000
+	}
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd parameter
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; //ori         v0,zero,0
+	}
+	// Insert calling system code
+	call_lib_code(LIB_SYSTEM | EXTRA_SERIAL);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+char* serialout_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SYSTEM | EXTRA_SERIALOUT);
+	return 0;
+}
+char* serialin_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; //ori         v0,zero,0000
+	} else {
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_SYSTEM | EXTRA_SERIALIN);
+	return 0;
+}

--- mips/trunk/megalopa/main.h	(nonexistent)
+++ mips/trunk/megalopa/main.h	(revision 268)
@@ -0,0 +1,22 @@
+/*
+   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 MEGALOPA
+#define SYSVER1 "Megalopa"
+#define SYSVER2 "1.0"
+#define BASVER "KM-1300"
+
+#define INIFILE "MACHIKAM.INI" // 初期設定ファイル
+#define HEXFILE "MACHIKAM.HEX" // 実行中HEXファイル名がこれと一致した場合はエディタ起動
+
+#define FILENAME_FLASH_ADDRESS 0x9D07EFF0
+#define PIC32MX_RAMSIZE 0x20000
+#define PIC32MX_FLASHSIZE 0x80000
+
+void printhex8(unsigned char d);
+void printhex16(unsigned short d);
+void printhex32(unsigned int d);

--- mips/trunk/megalopa/music.c	(nonexistent)
+++ mips/trunk/megalopa/music.c	(revision 268)
@@ -0,0 +1,902 @@
+/*
+   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"
+
+/*
+	Tone data for 15700 Hz sampling frequency,
+	supporting 3.4 Hz - 440 Hz - 31400 Hz,
+	are 2147483647 - 16777216 (2^24) - 235095, respectively.
+	The counter for DMA is working 470189 times more than the actual clock.
+	Therefore, 440 Hz correspond to 16777216 (= 470189 * 15700/440) counts of this timer.
+
+	Example:
+	When producing 440 Hz signal, the timer (initially set to 16777216) will be decreased 
+	by 470189 at 15700 Hz frequency. When the timer will be equal to or less than half of 
+	16777216 (8388608), toggle output. When the timer will be zero or negative, toggle 
+	output and add 16777216 to timer.
+*/
+
+/*
+	c	14107904
+	B	14946809
+	A#	15835575
+	A	16777216
+	G#	17774828
+	G	18831809
+	F#	19951607
+	F	21137982
+	E	22394866
+	D#	23726565
+	D	25137402
+	C#	26632135
+	C	28215755
+	Cb	29893558
+*/
+
+const static int g_keys[]={
+	15835575,14107904,26632135,23726565,21137982,19951607,17774828,//  0 7# C# A#m
+	15835575,14946809,26632135,23726565,21137982,19951607,17774828,//  7 6# F# D#m
+	15835575,14946809,26632135,23726565,22394866,19951607,17774828,// 14 5# B  G#m
+	16777216,14946809,26632135,23726565,22394866,19951607,17774828,// 21 4# E  C#m
+	16777216,14946809,26632135,25137402,22394866,19951607,17774828,// 28 3# A  F#m
+	16777216,14946809,26632135,25137402,22394866,19951607,18831809,// 35 2# D  Bm
+	16777216,14946809,28215755,25137402,22394866,19951607,18831809,// 42 1# G  Em
+	16777216,14946809,28215755,25137402,22394866,21137982,18831809,// 49 0  C  Am
+	16777216,15835575,28215755,25137402,22394866,21137982,18831809,// 56 1b F  Dm
+	16777216,15835575,28215755,25137402,23726565,21137982,18831809,// 63 2b Bb Gm
+	17774828,15835575,28215755,25137402,23726565,21137982,18831809,// 70 3b Eb Cm
+	17774828,15835575,28215755,26632135,23726565,21137982,18831809,// 77 4b Ab Fm
+	17774828,15835575,28215755,26632135,23726565,21137982,19951607,// 84 5b Db Bbm
+	17774828,15835575,29893558,26632135,23726565,21137982,19951607,// 91 6b Gb Ebm
+	17774828,15835575,29893558,26632135,23726565,22394866,19951607,// 98 7b Cb Abm
+};
+
+/*
+	2^(1/12)     ~= 1+1/16-1/256
+	1/(2^(1/12)) ~= 1-1/16+1/128-1/512
+*/
+
+#define toneFlat(x) ((x)+((x)>>4)-((x)>>8))
+#define toneSharp(x) ((x)-((x)>>4)+((x)>>7)-((x)>>9))
+
+/* 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 int g_musicL[32];
+static int g_soundL[32];
+static unsigned short g_musiclenL[32];
+static unsigned char g_soundlenL[32];
+static int g_musicstartL;
+static int g_musicendL;
+static int g_musicwaitL;
+static int g_soundstartL;
+static int g_soundendL;
+static int g_soundwaitL;
+static int g_soundrepeatL;
+static int g_musicR[32];
+static int g_soundR[32];
+static unsigned short g_musiclenR[32];
+static unsigned char g_soundlenR[32];
+static int g_musicstartR;
+static int g_musicendR;
+static int g_musicwaitR;
+static int g_soundstartR;
+static int g_soundendR;
+static int g_soundwaitR;
+static int g_soundrepeatR;
+
+#define MFLAG_L 2
+#define MFLAG_R 1
+
+static char g_sound_mode=0;
+static FSFILE* g_fhandle=0;
+static unsigned char* wavtable=0;
+static int wave_stereo;
+#define wave_sector_size (wave_stereo ? 524 : 262)
+
+#define SOUND_MODE_NONE 0
+#define SOUND_MODE_MUSIC 1
+#define SOUND_MODE_WAVE 2
+
+#define start_wavedma() T4CONSET=0x8000; DCH1CONSET=DCH2CONSET=0x00000080
+#define stop_wavedma()  T4CONCLR=0x8000; DCH1CONCLR=DCH2CONCLR=0x00000080; g_sound_mode=SOUND_MODE_NONE
+
+void init_wave_dma();
+
+int musicRemaining(int flagsLR){
+	int l, r;
+	l=(g_musicendL-g_musicstartL)&31;
+	r=(g_musicendL-g_musicstartL)&31;
+	if (flagsLR & MFLAG_L) return l;
+	if (flagsLR & MFLAG_R) return r;
+	return (l>r) ? l:r;
+}
+
+int waveRemaining(int mode){
+	int ret;
+	if (!g_fhandle) return 0;
+	switch(mode){
+		case 1: // current position (header excluded)
+			ret=g_fhandle->seek-0x2c;
+			break;
+		case 2: // file size (header excluded)
+			ret=g_fhandle->size-0x2c;
+			break;
+		case 0: // remaining
+		default:
+			ret=g_fhandle->size-g_fhandle->seek;
+			break;
+	}
+	if (wave_stereo) ret=ret>>1;
+	return ret;
+}
+
+#pragma interrupt musicint IPL2SOFT vector 1
+void musicint(){
+	static unsigned short wavtable_pos;
+	static int music_freq_L=0;
+	static int music_timer_L=0;
+	static int music_freq_R=0;
+	static int music_timer_R=0;
+	unsigned int i,j;
+	// This function is called every 1/60 sec.
+	IFS0bits.CS0IF=0;
+	switch(g_sound_mode){
+		case SOUND_MODE_WAVE:
+			// Initialize parameters
+			if (!T4CONbits.ON){
+				wavtable_pos=0;
+				music_timer_L=music_timer_R=0;
+				start_wavedma();
+			}
+			wavtable_pos=wave_sector_size-wavtable_pos;
+			// Read from file
+			if (0 == FSfread((void*)&wavtable[wavtable_pos],1,wave_sector_size,g_fhandle)) {
+				// End of file.
+				stop_wavedma();
+				FSfclose(g_fhandle);
+				g_fhandle=0;
+				g_sound_mode=SOUND_MODE_NONE;
+				stop_music();
+				break;
+			}
+			// Continue to MUSIC sound mode
+		case SOUND_MODE_MUSIC:
+			// Left sound/music
+			if (g_soundstartL!=g_soundendL){
+				// Start timer
+				music_freq_L=g_soundL[g_soundstartL];
+				if ((--g_soundwaitL)<=0) {
+					g_soundstartL++;
+					if (g_soundstartL==g_soundendL || 31<g_soundstartL) {
+						g_soundstartL=0;
+						g_soundrepeatL--;
+						if (0<g_soundrepeatL) {
+							g_soundwaitL=g_soundlenL[g_soundstartL];
+						} else {
+							g_soundendL=g_soundrepeatL=g_soundwaitL=0;
+						}
+					} else {
+						g_soundwaitL=g_soundlenL[g_soundstartL];
+					}
+				}
+				// Shift music data even though without output.
+				if (g_musicstartL!=g_musicendL) {
+					if ((--g_musicwaitL)<=0) {
+						g_musicstartL++;
+						g_musicstartL&=31;
+						g_musicwaitL=g_musiclenL[g_musicstartL];
+					}
+				}
+			} else if (g_musicstartL!=g_musicendL) {
+				// Start timer
+				music_freq_L=g_musicL[g_musicstartL];
+				if ((--g_musicwaitL)<=0) {
+					g_musicstartL++;
+					g_musicstartL&=31;
+					g_musicwaitL=g_musiclenL[g_musicstartL];
+				}
+			} else {
+				music_freq_L=0;
+			}
+			// Right sound/music
+			if (g_soundstartR!=g_soundendR){
+				// Start timer
+				music_freq_R=g_soundR[g_soundstartR];
+				if ((--g_soundwaitR)<=0) {
+					g_soundstartR++;
+					if (g_soundstartR==g_soundendR || 31<g_soundstartR) {
+						g_soundstartR=0;
+						g_soundrepeatR--;
+						if (0<g_soundrepeatR) {
+							g_soundwaitR=g_soundlenR[g_soundstartR];
+						} else {
+							g_soundendR=g_soundrepeatR=g_soundwaitR=0;
+						}
+					} else {
+						g_soundwaitR=g_soundlenR[g_soundstartR];
+					}
+				}
+				// Shift music data even though without output.
+				if (g_musicstartR!=g_musicendR) {
+					if ((--g_musicwaitR)<=0) {
+						g_musicstartR++;
+						g_musicstartR&=31;
+						g_musicwaitR=g_musiclenR[g_musicstartR];
+					}
+				}
+			} else if (g_musicstartR!=g_musicendR) {
+				// Start timer
+				music_freq_R=g_musicR[g_musicstartR];
+				if ((--g_musicwaitR)<=0) {
+					g_musicstartR++;
+					g_musicstartR&=31;
+					g_musicwaitR=g_musiclenR[g_musicstartR];
+				}
+			} else {
+				music_freq_R=0;
+			}
+			// music_freq_L/R is controlling music/sound.
+			// If this value is valid, make sound with this frequency
+			if (g_sound_mode!=SOUND_MODE_WAVE) {
+				if (!T4CONbits.ON){
+					// Initialize parameters
+					wavtable_pos=0;
+					music_timer_L=music_timer_R=0;
+					start_wavedma();
+					// Silent in the first sector
+					for(i=0;i<wave_sector_size;i++) wavtable[i]=0x80;
+				}
+				wavtable_pos=wave_sector_size-wavtable_pos;
+			}
+			// Modify WAVE table (SOUND_MODE_WAVE) or construct WAVE table (SOUND_MODE_MUSIC)
+			if (g_sound_mode==SOUND_MODE_WAVE && music_freq_L==0 && music_freq_R==0) {
+				// Modification is not needed
+				break;
+			}
+			for(i=0;i<wave_sector_size;i++){
+				if (music_freq_L) {
+					music_timer_L-=470189;
+					if (music_timer_L<=0) {
+						music_timer_L+=music_freq_L;
+						j=0xc0;
+					} else if (music_timer_L<=(music_freq_L>>1)) {
+						j=0x40;
+					} else {
+						j=0xc0;
+					}
+				} else {
+						j=0x80;
+				}
+				if (g_sound_mode==SOUND_MODE_WAVE) {
+					// In WAVE mode, MUSIC/SOUND data is added to WAVE data
+					j-=0x80;
+					j+=wavtable[wavtable_pos+i];
+					if (j<0x00) j=0;
+					else if (0xff<j) j=0xff;
+					wavtable[wavtable_pos+i]=j;
+				} else {
+					// In MUSIC mode, MUSIC/SOUND data is newly created
+					wavtable[wavtable_pos+i]=j;
+				}
+				if (music_freq_R) {
+					music_timer_R-=470189;
+					if (music_timer_R<=0) {
+						music_timer_R+=music_freq_R;
+						j=0xc0;
+					} else if (music_timer_R<=(music_freq_R>>1)) {
+						j=0x40;
+					} else {
+						j=0xc0;
+					}
+				} else {
+						j=0x80;
+				}
+				if (wave_stereo) {
+					if (g_sound_mode==SOUND_MODE_WAVE) {
+						// In WAVE mode, MUSIC/SOUND data is added to WAVE data
+						j-=0x80;
+						j+=wavtable[wavtable_pos+i+1];
+						if (j<0x00) j=0;
+						else if (0xff<j) j=0xff;
+						wavtable[wavtable_pos+i+1]=j;
+					} else {
+						wavtable[wavtable_pos+i+1]=j;
+						// In MUSIC mode, MUSIC/SOUND data is newly created
+					}
+					// Increment i here and in if statement (total addition 2 for stereo mode)
+					i++;
+				}	
+			}
+			break;
+		case SOUND_MODE_NONE:
+			music_freq_L=0;
+			music_timer_L=0;
+			music_freq_R=0;
+			music_timer_R=0;
+			// Move OC3RS and OC4RS to 0x80 if less or more.
+			if (OC3RS<0x80) {
+				OC3RS++;
+			} else if (0x80<OC3RS) {
+				OC3RS--;
+			}
+			if (OC4RS<0x80) {
+				OC4RS++;
+			} else if (0x80<OC4RS) {
+				OC4RS--;
+			}
+			if (OC3RS==0x80 && OC4RS==0x80) {
+				// Stop interrupt
+				IEC0bits.CS0IE=0;
+			}
+			break;
+		default:
+			break;
+	}
+}
+
+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;
+}
+
+static const unsigned int inv_rf4[1]={0x00000010};
+static const unsigned int inv_rf5[1]={0x00000020};
+
+void init_normal_music(){
+	// Use Timer3 and DMA2 for left (RF5)
+	// Use Timer4 and DMA1 for right (RF4)
+	stop_music();
+
+	// Alocate 524*2 byte buffer if not assigned
+	if (g_var_size[ALLOC_WAVE_BLOCK]==0) {
+		wavtable=(char*)alloc_memory(524*2/4,ALLOC_WAVE_BLOCK);
+	}
+
+	// Set music mode
+	g_sound_mode=SOUND_MODE_MUSIC;
+	wave_stereo=1;
+
+	// DMA setting 
+	init_wave_dma();
+
+	// Software interrupt every 1/60 sec (triggered by Timer2)
+	IFS0bits.CS0IF=0;
+	IEC0bits.CS0IE=1;	
+}
+
+void init_music(){
+	// Currently this function is called in main.c and run.c
+	stop_music();
+
+	// 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_musicstartL=g_musicendL=g_musicwaitL=g_soundstartL=g_soundendL=g_soundwaitL=g_soundrepeatL=0;
+	g_musicstartR=g_musicendR=g_musicwaitR=g_soundstartR=g_soundendR=g_soundwaitR=g_soundrepeatR=0;
+
+	// Timer3 for PWM
+	T3CON=0x0000;
+	PR3=0x100;
+	TMR3=0;
+
+	// OC4 setting
+	RPF5R = 0x0b;    //Use RPF5 for OC4
+	if (OC4RS&0xff00) OC4RS=0x00;
+	OC4CON=0x000e;
+	OC4CONSET=0x8000;
+	// OC3 setting
+	RPF4R = 0x0b;    //Use RPF4 for OC3
+	if (OC3RS&0xff00) OC3RS=0x00;
+	OC3CON=0x000e;
+	OC3CONSET=0x8000;
+
+	// Start timer3
+	T3CON=0x8000;
+
+	// Move OC4RS and OC3 RS from 0x00 to 0x80
+	g_sound_mode=SOUND_MODE_NONE;
+	// Enable interrupt
+	IPC0bits.CS0IP=2;
+	IPC0bits.CS0IS=0;
+	IFS0bits.CS0IF=0;
+	IEC0bits.CS0IE=1;
+}
+
+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 flagsLR){
+	int sound;
+	int len;
+	int pos;
+	int datalen;
+	if (g_sound_mode==SOUND_MODE_NONE) {
+		// Start normal music mode
+		init_normal_music();
+	}
+	IEC0bits.CS0IE=0; // Stop interruption, first.
+	// Initialize
+	if (flagsLR & MFLAG_L) g_soundrepeatL=g_soundstartL=g_soundendL=0;
+	if (flagsLR & MFLAG_R) g_soundrepeatR=g_soundstartR=g_soundendR=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 for 2048 <--> ~440 Hz.
+				// 2048 = 2^11
+				// 16777216 = 2^24
+				sound=sound<<13;
+				if (flagsLR & MFLAG_L) g_soundL[pos]=sound;
+				if (flagsLR & MFLAG_R) g_soundR[pos]=sound;
+				if (flagsLR & MFLAG_L) g_soundlenL[pos]=len;
+				if (flagsLR & MFLAG_R) g_soundlenR[pos]=len;
+				pos++;
+				if (32<pos) {
+					err_music("Sound data too long.");
+					return;
+				}
+			} else {
+				if (flagsLR & MFLAG_L) g_soundrepeatL=sound;
+				if (flagsLR & MFLAG_R) g_soundrepeatR=sound;
+				break;
+			}
+		}
+	} while(len);
+	if (flagsLR & MFLAG_L) g_soundendL=pos;
+	if (flagsLR & MFLAG_R) g_soundendR=pos;
+	if (flagsLR & MFLAG_L) g_soundwaitL=g_soundlenL[0];
+	if (flagsLR & MFLAG_R) g_soundwaitR=g_soundlenR[0];
+	IEC0bits.CS0IE=1; // Restart interrupt.
+}
+
+void set_music(char* str, int flagsLR){
+	char b;
+	unsigned long tone,tonenatural;
+	int len;
+	if (g_sound_mode==SOUND_MODE_NONE) {
+		// Start normal music mode
+		init_normal_music();
+	}
+	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();
+			}
+			// Update music value array
+			IEC0bits.CS0IE=0; // Stop interruption, first.
+			// Update left music
+			if (flagsLR & MFLAG_L) {
+				if (g_musicstartL==g_musicendL) {
+					g_musicwaitL=len;
+				}
+				g_musicL[g_musicendL]=tone;
+				g_musiclenL[g_musicendL]=len;
+				g_musicendL++;
+				g_musicendL&=31;
+			}
+			// Update right music
+			if (flagsLR & MFLAG_R) {
+				if (g_musicstartR==g_musicendR) {
+					g_musicwaitR=len;
+				}
+				g_musicR[g_musicendR]=tone;
+				g_musiclenR[g_musicendR]=len;
+				g_musicendR++;
+				g_musicendR&=31;
+			}
+			IEC0bits.CS0IE=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++;
+	}
+}
+
+/*
+	In WAVE mode (for both stereo and monaural):
+		DMA2/OC4 is used for left
+		DMA1/OC3 is used for right
+		Timer 3 is used for PWM for both L/R
+		Timer 4 is used for both DMA1/DMA2
+*/
+
+int checkChars(char* str1, char* str2, int num){
+	int i;
+	for(i=0;i<num;i++){
+		if (str1[i]!=str2[i]) return 1;
+	}
+	return 0;
+}
+
+FSFILE* openWave(char* file){
+	FSFILE *fp;
+	int i;
+
+	// Open Wave file
+	fp=FSfopen(file,"r");
+	if(fp==NULL) err_file();
+
+	// Read the header
+	if (0x2c != FSfread((void*)&wavtable[0],1,0x2c,fp)) {
+		err_wave();
+	}
+	i=0;
+	i+=checkChars((char*)&wavtable[0],"RIFF",4);                      // Check RIFF
+	i+=checkChars((char*)&wavtable[8],"WAVEfmt ",8);                  // Check WAVE and fmt
+	i+=checkChars((char*)&wavtable[16],"\x10\x00\x00\x00\x01\x00",6); // Check if liear PCM
+	if (!checkChars((char*)&wavtable[22],"\x02\x00\x80\x3e\x00\x00\x00\x7d\x00\x00\x02\x00",12)) {
+		// Stereo 16000 Hz
+		wave_stereo=1;
+	} else if (!checkChars((char*)&wavtable[22],"\x01\x00\x80\x3e\x00\x00\x80\x3e\x00\x00\x01\x00",12)) {
+		// Monaural 16000 Hz
+		wave_stereo=0;
+	} else if (!checkChars((char*)&wavtable[22],"\x02\x00\x54\x3d\x00\x00\xa8\x7a\x00\x00\x02\x00",12)) {
+		// Stereo 15700 Hz
+		wave_stereo=1;
+	} else if (!checkChars((char*)&wavtable[22],"\x01\x00\x54\x3d\x00\x00\x54\x3d\x00\x00\x01\x00",12)) {
+		// Monaural 15700 Hz
+		wave_stereo=0;
+	} else {
+		i=1;
+	}
+	i+=checkChars((char*)&wavtable[34],"\x08\x00\x64\x61\x74\x61",6); // Check bit # and data
+	if (i) {
+		err_wave();
+	}
+	return fp;
+}
+
+void init_wave_dma(){
+	// Timer4 for 15700 Hz
+	TMR4=0;
+	PR4=6080-1;
+	TMR4=PR4-1;
+	T4CON=0x0000; // Not start yet
+
+	if (wave_stereo) {
+		//DMA2 settings for OC4 for left
+		DMACONSET=0x8000;
+		DCH2CON=0x00000012;  // CHBUSY=0, CHCHNS=0, CHEN=0, CHAED=0, CHCHN=0, CHAEN=1, CHEDET=0, CHPRI=b10
+		DCH2ECON=0x1310;     // CHAIRQ=0, CHSIRQ=19, CFORCE=0, CABRT=0, PATEN=0, SIRQEN=1, AIRQEN=0
+		                     // CHSIRQ=19: Timer4 interrupt
+		DCH2SSA=((unsigned int)&(wavtable[-1]))&0x1fffffff;
+		DCH2DSA=0x1F803620-1; // OC4RS
+		DCH2SSIZ=524*2;
+		DCH2DSIZ=2;
+		DCH2CSIZ=2;
+		DCH2INTCLR=0x00FF00FF;
+		DCH2CONSET=0x00000080;
+	
+		//DMA1 settings for OC3 for rifht
+		DMACONSET=0x8000;
+		DCH1CON=0x00000012;  // CHBUSY=0, CHCHNS=0, CHEN=0, CHAED=0, CHCHN=0, CHAEN=1, CHEDET=0, CHPRI=b10
+		DCH1ECON=0x1310;     // CHAIRQ=0, CHSIRQ=19, CFORCE=0, CABRT=0, PATEN=0, SIRQEN=1, AIRQEN=0
+		                     // CHSIRQ=19: Timer4 interrupt
+		DCH1SSA=((unsigned int)&(wavtable[0]))&0x1fffffff;
+		DCH1DSA=0x1F803420-1; // OC3RS
+		DCH1SSIZ=524*2;
+		DCH1DSIZ=2;
+		DCH1CSIZ=2;
+		DCH1INTCLR=0x00FF00FF;
+		DCH1CONSET=0x00000080;
+	} else {
+		//DMA2 settings for OC4 for left
+		DMACONSET=0x8000;
+		DCH2CON=0x00000012;  // CHBUSY=0, CHCHNS=0, CHEN=0, CHAED=0, CHCHN=0, CHAEN=1, CHEDET=0, CHPRI=b10
+		DCH2ECON=0x1310;     // CHAIRQ=0, CHSIRQ=19, CFORCE=0, CABRT=0, PATEN=0, SIRQEN=1, AIRQEN=0
+		                     // CHSIRQ=19: Timer4 interrupt
+		DCH2SSA=((unsigned int)&(wavtable[0]))&0x1fffffff;
+		DCH2DSA=0x1F803620; // OC4RS
+		DCH2SSIZ=524;
+		DCH2DSIZ=1;
+		DCH2CSIZ=1;
+		DCH2INTCLR=0x00FF00FF;
+		DCH2CONSET=0x00000080;
+	
+		//DMA1 settings for OC3 for rifht
+		DMACONSET=0x8000;
+		DCH1CON=0x00000012;  // CHBUSY=0, CHCHNS=0, CHEN=0, CHAED=0, CHCHN=0, CHAEN=1, CHEDET=0, CHPRI=b10
+		DCH1ECON=0x1310;     // CHAIRQ=0, CHSIRQ=19, CFORCE=0, CABRT=0, PATEN=0, SIRQEN=1, AIRQEN=0
+		                     // CHSIRQ=19: Timer4 interrupt
+		DCH1SSA=((unsigned int)&(wavtable[0]))&0x1fffffff;
+		DCH1DSA=0x1F803420; // OC3RS
+		DCH1SSIZ=524;
+		DCH1DSIZ=1;
+		DCH1CSIZ=1;
+		DCH1INTCLR=0x00FF00FF;
+		DCH1CONSET=0x00000080;
+	}
+
+}
+
+void play_wave(char* filename, int start){
+	// First of all, stop music.
+	stop_music();
+	// Exit function if null filename
+	if (filename[0]==0x00) {
+		OC3RS=OC4RS=0x80;
+		return;
+	}
+	// Alocate 524*2 byte buffer if not assigned
+	if (g_var_size[ALLOC_WAVE_BLOCK]==0) {
+		wavtable=(char*)alloc_memory(524*2/4,ALLOC_WAVE_BLOCK);
+	}
+	// Open file
+	if (g_fhandle) FSfclose(g_fhandle);
+	g_fhandle=openWave(filename);
+	// Support defined start position here to skip file pointer here.
+	if (wave_stereo) start=start<<1;
+	FSfseek(g_fhandle, start, SEEK_CUR);
+	// Read first 262/524 words.
+	if (wave_sector_size != FSfread((void*)&wavtable[0],1,wave_sector_size,g_fhandle)) err_file();
+	// Initialize DMA
+	init_wave_dma();	
+	g_sound_mode=SOUND_MODE_WAVE;
+	// Enable intterupt
+	IFS0bits.CS0IF=0;
+	IEC0bits.CS0IE=1;
+}
+
+void stop_music(){
+	// Set NONE sound mode
+	g_sound_mode=SOUND_MODE_NONE;
+	// Stop DMA1 and DMA2
+	DCH1CONCLR=0x00000080;
+	DCH2CONCLR=0x00000080;
+	// Close WAVE file if open
+	if (g_fhandle) {
+		FSfclose(g_fhandle);
+		g_fhandle=0;
+	}
+}

--- mips/trunk/megalopa/envspecific.c	(nonexistent)
+++ mips/trunk/megalopa/envspecific.c	(revision 268)
@@ -0,0 +1,312 @@
+/*
+   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 "lib_video_megalopa.h"
+#include "ps2keyboard.h"
+#include "io.h"
+
+/*
+	int readbuttons();
+	Read the tact switches.
+	For Zoea, disable PS/2 keyboard and enable tact switches, then read.
+*/
+
+int readbuttons(){
+	return KEYPORT;
+}
+
+/*
+	void pre_run(void);
+	void post_run(void);
+	Called before after execution of BASIC code.
+*/
+
+void pre_run(void){
+	// Reset PWM
+	lib_pwm(0,0,0);
+}
+void post_run(void){
+	if (graphmode==GMODE_ZOEAGRPH) {
+		// Stop graph mode when using Zoea compatible one.
+		usegraphic(0);
+		g_use_graphic=0;
+	}
+}
+
+
+
+/*
+	init_env();
+	Initialize envionment.
+*/
+
+void init_env(void){
+	// Reset PWM
+	lib_pwm(0,0,0);
+}
+
+/*
+	void scroll(int x, int y);
+	Scroll 
+*/
+
+void scroll(int x,int y){
+	int i,j;
+	int vector=y*twidth+x;
+	if (vector<0) {
+		// Copy data from upper address to lower address
+		for(i=0-vector;i<twidth*WIDTH_Y;i++){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[twidth*WIDTH_Y+i+vector]=TVRAM[twidth*WIDTH_Y+i];
+		}
+	} else if (0<vector) {
+		// Copy data from lower address to upper address
+		for(i=twidth*WIDTH_Y-vector-1;0<=i;i--){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[twidth*WIDTH_Y+i+vector]=TVRAM[twidth*WIDTH_Y+i];
+		}
+	} else {
+		return;
+	}
+	if (x<0) {
+		// Fill blanc at right
+		for(i=x;i<0;i++){
+			for(j=twidth+i;j<twidth*WIDTH_Y;j+=twidth){
+				TVRAM[j]=0x00;
+				TVRAM[twidth*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	} else if (0<x) {
+		// Fill blanc at left
+		for(i=0;i<x;i++){
+			for(j=i;j<twidth*WIDTH_Y;j+=twidth){
+				TVRAM[j]=0x00;
+				TVRAM[twidth*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	}
+	if (y<0) {
+		// Fill blanc at bottom
+		for(i=twidth*(WIDTH_Y+y);i<twidth*WIDTH_Y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[twidth*WIDTH_Y+i]=cursorcolor;
+		}
+	} else if (0<y) {
+		// Fill blanc at top
+		for(i=0;i<twidth*y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[twidth*WIDTH_Y+i]=cursorcolor;
+		}
+	}
+}
+
+void allocate_graphic_area(int mode){
+	static int prevmode=-1;
+	if (g_graphic_area) {
+		if (mode==prevmode) {
+			// Do nothing
+			return;
+		} else {
+			// Clear previous area here
+			free_temp_str((char*)g_graphic_area);
+			g_graphic_area=0;
+		}
+	}
+	switch (mode) {
+		case 0:
+			g_graphic_area=alloc_memory(X_RESZ*Y_RESZ/2/4,ALLOC_GRAPHIC_BLOCK);
+			break;
+		case 1:
+			g_graphic_area=alloc_memory(X_RES*Y_RES/4,ALLOC_GRAPHIC_BLOCK);
+			break;
+		case 2:
+			g_graphic_area=alloc_memory(X_RESW*Y_RES/4,ALLOC_GRAPHIC_BLOCK);
+			break;
+		default:
+			err_invalid_param();
+	}
+	// Store current graphic mode
+	prevmode=mode;
+}
+
+void start_graphic(int mode){
+	if (!g_graphic_area) return;
+	switch (mode) {
+		case 0:
+			set_videomode(VMODE_ZOEAGRPH,(unsigned char *)g_graphic_area);
+			break;
+		case 1:
+			set_videomode(VMODE_STDGRPH,(unsigned char *)g_graphic_area);
+			break;
+		case 2:
+			set_videomode(VMODE_WIDEGRPH,(unsigned char *)g_graphic_area);
+			break;
+		default:
+			err_invalid_param();
+	}
+}
+
+void usegraphic(int mode){
+	if (mode<0 || 11<mode) err_invalid_param();
+	switch(mode & 3){
+		// Modes; 0: stop GRAPHIC, 1: use GRAPHIC, 2: reset GRAPHIC and use it, 3: allocate GRAPHIC area but not use it
+		case 0:
+			if (g_use_graphic){
+				// Stop GRAPHIC if used
+				set_videomode(textmode,0);
+				g_use_graphic=0;
+			} else {
+				// Prepare GRAPHIC area if not used and not allcated.
+				allocate_graphic_area(mode>>2);
+			}
+			break;
+		case 2:
+			// Reset GRAPHIC and use it
+			if (g_graphic_area) {
+				g_clearscreen();
+				init_palette();
+			}
+			// Continue to case 1:
+		case 1:
+		case 3:
+		default:
+			// Use GRAPHIC
+			allocate_graphic_area(mode>>2);
+			// Start showing GRAPHIC with mode 1, but not with mode 3
+			if ((mode & 3) !=3 && !g_use_graphic){
+				// Change to graphic mode.
+				start_graphic(mode>>2);
+				g_use_graphic=1;
+			}
+			break;
+	}
+}
+
+int lib_system(int a0, int a1 ,int v0, int a3, int g_gcolor, int g_prev_x, int g_prev_y){
+	switch((enum extra)(a3 & EXTRA_MASK)){
+		case EXTRA_SYSTEM:
+			// SYSTEM statement/function (see below)
+			break;
+		case EXTRA_OUT:
+			lib_out(g_libparams[1],v0);
+			return v0;
+		case EXTRA_OUT8H:
+			lib_out8h(v0);
+			return v0;
+		case EXTRA_OUT8L:
+			lib_out8l(v0);
+			return v0;
+		case EXTRA_OUT16:
+			lib_out16(v0);
+			return v0;
+		case EXTRA_IN:
+			return lib_in(v0);
+		case EXTRA_IN8H:
+			return lib_in8h();
+		case EXTRA_IN8L:
+			return lib_in8l();
+		case EXTRA_IN16:
+			return lib_in16();
+		case EXTRA_ANALOG:
+			return lib_analog(v0);
+		case EXTRA_PWM:
+			lib_pwm(g_libparams[1],g_libparams[2],v0);
+			return v0;
+		case EXTRA_SERIAL:
+			lib_serial(g_libparams[1],g_libparams[2],v0);
+			return v0;
+		case EXTRA_SERIALOUT:
+			lib_serialout(v0);
+			return v0;
+		case EXTRA_SERIALIN:
+			return lib_serialin(v0);
+		case EXTRA_SPI:
+		case EXTRA_SPIOUT:
+		case EXTRA_SPIIN:
+			// TODO: Implement IO functions
+			return v0;
+		default:
+			err_unknown();
+			return 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 twidth;
+		case 21: return twidthy;
+		case 22: return gwidth;
+		case 23: return gwidthy;
+		case 24: return cursorcolor;
+		case 25: return g_gcolor;
+		case 26: return ((int)(cursor-TVRAM))%twidth;
+		case 27: return ((int)(cursor-TVRAM))/twidth;
+		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;
+}
+
+void videowidth(int width){
+	switch(width){
+		case 30:
+			set_videomode(VMODE_T30,0);
+			break;
+		case 36:
+			set_videomode(VMODE_STDTEXT,0);
+			break;
+		case 40:
+			set_videomode(VMODE_T40,0);
+			break;
+		case 48:
+			set_videomode(VMODE_WIDETEXT,0);
+			break;
+		case 64:
+			set_videomode(VMODE_WIDETEXT6dot,0);
+			break;
+		case 80:
+			set_videomode(VMODE_MONOTEXT,0);
+			break;
+		default:
+			// Do nothing
+			return;
+	}
+	g_use_graphic=0;
+}
+
+void set_graphmode(unsigned char m){
+	if (m==0) set_videomode(VMODE_T30,0);
+}

--- mips/trunk/megalopa/compiler.h	(nonexistent)
+++ mips/trunk/megalopa/compiler.h	(revision 268)
@@ -0,0 +1,376 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+// Include envilonment specific configurations
+#include "envspecific.h"
+
+/* Definitions */
+// Number of variables (including temporary ones)
+#define ALLOC_VAR_NUM 36
+// Block # dedicated for PCG
+#define ALLOC_PCG_BLOCK 36
+// Block # dedicated for GRAPHIC
+#define ALLOC_GRAPHIC_BLOCK 37
+// Block # dedicated for PLAYWAVE
+#define ALLOC_WAVE_BLOCK 38
+// Start # for long name variables
+#define ALLOC_LNV_BLOCK 39
+// Number of long name variables
+#define ALLOC_LNV_NUM 190
+// Start # of permanent blocks
+#define ALLOC_PERM_BLOCK 229
+// Number of blocks that can be assigned for memory allocation (including all above)
+#define ALLOC_BLOCK_NUM 239
+
+// Persistent RAM bytes used for object, heap and exception data
+#ifndef PERSISTENT_RAM_SIZE
+	// This must be defined in envspecific.h
+	#define PERSISTENT_RAM_SIZE (1024*53)
+#endif
+// 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
+};
+
+#define OP_MASK 0x001F
+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
+};
+
+#define LIB_MASK 0xFE00
+#define LIB_STEP 0x0200
+enum libs{
+	LIB_SOUND          =LIB_STEP*0,
+	LIB_MUSICFUNC      =LIB_STEP*1,
+	LIB_MUSIC          =LIB_STEP*2,
+	LIB_SETDRAWCOUNT   =LIB_STEP*3,
+	LIB_DRAWCOUNT      =LIB_STEP*4,
+	LIB_PALETTE        =LIB_STEP*5,
+	LIB_GPALETTE       =LIB_STEP*6,
+	LIB_BGCOLOR        =LIB_STEP*7,
+	LIB_CURSOR         =LIB_STEP*8,
+	LIB_CLS            =LIB_STEP*9,
+	LIB_GCLS           =LIB_STEP*10,
+	LIB_COLOR          =LIB_STEP*11,
+	LIB_GCOLOR         =LIB_STEP*12,
+	LIB_KEYS           =LIB_STEP*13,
+	LIB_RESTORE        =LIB_STEP*14,
+	LIB_RESTORE2       =LIB_STEP*15,
+	LIB_READ           =LIB_STEP*16,
+	LIB_MIDSTR         =LIB_STEP*17,
+	LIB_CLEAR          =LIB_STEP*18,
+	LIB_DIV0           =LIB_STEP*19,
+	LIB_LETSTR         =LIB_STEP*20,
+	LIB_STRNCMP        =LIB_STEP*21,
+	LIB_RND            =LIB_STEP*22,
+	LIB_DEC            =LIB_STEP*23,
+	LIB_HEX            =LIB_STEP*24,
+	LIB_CHR            =LIB_STEP*25,
+	LIB_CONNECT_STRING =LIB_STEP*26,
+	LIB_STRING         =LIB_STEP*27,
+	LIB_PRINTSTR       =LIB_STEP*28,
+	LIB_LABEL          =LIB_STEP*29,
+	LIB_DIM            =LIB_STEP*30,
+	LIB_VAL            =LIB_STEP*31,
+	LIB_INPUT          =LIB_STEP*32,
+	LIB_INKEY          =LIB_STEP*33,
+	LIB_USEPCG         =LIB_STEP*34,
+	LIB_PCG            =LIB_STEP*35,
+	LIB_SCROLL         =LIB_STEP*36,
+	LIB_WAIT           =LIB_STEP*37,
+	LIB_VAR_PUSH       =LIB_STEP*38,
+	LIB_VAR_POP        =LIB_STEP*39,
+	LIB_SYSTEM         =LIB_STEP*40,
+	LIB_SPRINTF        =LIB_STEP*41,
+	LIB_FLOAT          =LIB_STEP*42,
+	LIB_FLOATFUNCS     =LIB_STEP*43,
+	LIB_CREAD          =LIB_STEP*44,
+	LIB_USEGRAPHIC     =LIB_STEP*45,
+	LIB_GRAPHIC        =LIB_STEP*46,
+	LIB_WIDTH          =LIB_STEP*47,
+	LIB_FILE           =LIB_STEP*48,
+	LIB_PLAYWAVE       =LIB_STEP*49,
+	LIB_PLAYWAVEFUNC   =LIB_STEP*50,
+	LIB_DEBUG          =LIB_STEP*127,
+};
+
+// Note: OP_XXXX and FUNC_XXXX cannot be used simultaneously
+#define FUNC_MASK 0x003F
+#define FUNC_STEP 0x0001
+enum functions{
+	FUNC_FLOAT       =FUNC_STEP*0,
+	FUNC_INT         =FUNC_STEP*1,
+	FUNC_VALSHARP    =FUNC_STEP*2,
+	FUNC_SIN         =FUNC_STEP*3,
+	FUNC_COS         =FUNC_STEP*4,
+	FUNC_TAN         =FUNC_STEP*5,
+	FUNC_ASIN        =FUNC_STEP*6,
+	FUNC_ACOS        =FUNC_STEP*7,
+	FUNC_ATAN        =FUNC_STEP*8,
+	FUNC_ATAN2       =FUNC_STEP*9,
+	FUNC_SINH        =FUNC_STEP*10,
+	FUNC_COSH        =FUNC_STEP*11,
+	FUNC_TANH        =FUNC_STEP*12,
+	FUNC_EXP         =FUNC_STEP*13,
+	FUNC_LOG         =FUNC_STEP*14,
+	FUNC_LOG10       =FUNC_STEP*15,
+	FUNC_POW         =FUNC_STEP*16,
+	FUNC_SQRT        =FUNC_STEP*17,
+	FUNC_CEIL        =FUNC_STEP*18,
+	FUNC_FLOOR       =FUNC_STEP*19,
+	FUNC_FABS        =FUNC_STEP*20,
+	FUNC_MODF        =FUNC_STEP*21,
+	FUNC_FMOD        =FUNC_STEP*22,
+	FUNC_PSET        =FUNC_STEP*23,
+	FUNC_LINE        =FUNC_STEP*24,
+	FUNC_BOXFILL     =FUNC_STEP*25,
+	FUNC_CIRCLE      =FUNC_STEP*26,
+	FUNC_CIRCLEFILL  =FUNC_STEP*27,
+	FUNC_GPRINT      =FUNC_STEP*28,
+	FUNC_PUTBMP      =FUNC_STEP*29,
+	FUNC_PUTBMP2     =FUNC_STEP*30,
+	FUNC_GCOLOR      =FUNC_STEP*31,
+	FUNC_POINT       =FUNC_STEP*32,
+	FUNC_FOPEN       =FUNC_STEP*33,
+	FUNC_FOPENST     =FUNC_STEP*34,
+	FUNC_FILE        =FUNC_STEP*35,
+	FUNC_FCLOSE      =FUNC_STEP*36,
+	FUNC_FINPUT      =FUNC_STEP*37,
+	FUNC_FPRINTSTR   =FUNC_STEP*38,
+	FUNC_FGET        =FUNC_STEP*39,
+	FUNC_FPUT        =FUNC_STEP*40,
+	FUNC_FSEEK       =FUNC_STEP*41,
+	FUNC_FTELL       =FUNC_STEP*42,
+	FUNC_FLEN        =FUNC_STEP*43,
+	FUNC_FSTRING     =FUNC_STEP*44,
+	FUNC_FGETC       =FUNC_STEP*45,
+	FUNC_FPUTC       =FUNC_STEP*46,
+	FUNC_FREMOVE     =FUNC_STEP*47,
+	FUNC_FEOF        =FUNC_STEP*48,
+	FUNC_FINIT       =FUNC_STEP*49,
+	// MAX 63
+};
+
+/* Global vars (see globalvers.c) */
+extern int g_intconst;
+extern char g_valueisconst;
+extern unsigned 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;
+extern int* g_libparams;
+extern int g_long_name_var_num;
+extern int g_temp;
+
+/* 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);
+int endOfStatement();
+
+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);
+void err_invalid_param(void);
+void err_file(void);
+void err_wave(void);
+char* resolve_label(int s6);
+
+void set_sound(unsigned long* data, int flagsLR);
+int musicRemaining(int flagsLR);
+int waveRemaining(int mode);
+void set_music(char* str, int flagsLR);
+void stop_music(void);
+void init_music(void);
+void play_wave(char* filename, int start);
+
+char* statement(void);
+char* gosub_statement();
+char* graphic_statement(enum functions func);
+char* fopen_statement_main(enum functions func);
+char* fget_statement();
+char* fput_statement();
+char* fputc_statement();
+char* fremove_statement();
+
+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);
+int get_permanent_var_num(void);
+
+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);
+
+int lib_file(enum functions func, int a0, int a1, int v0);
+
+char* get_dim_value(int i);
+char* get_simple_value(void);
+char* get_value();
+char* get_floatOrValue();
+char* get_stringFloatOrValue();
+
+void blue_screen(void);
+
+char* get_float();
+
+void cmpdata_init();
+char* cmpdata_insert(unsigned char type, short data16, int* data, unsigned char num);
+void cmpdata_reset();
+int* cmpdata_find(unsigned char type);
+int* cmpdata_findfirst(unsigned char type);
+
+int check_var_name();
+int get_var_number();
+int search_var_name(int nameint);
+char* register_var_name(int nameint);
+
+
+/* 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])
+#define ERR_INVALID_PARAM (char*)(g_err_str[18])
+#define ERR_FILE (char*)(g_err_str[19])
+#define ERR_INVALID_VAR_NAME (char*)(g_err_str[20])
+#define ERR_WAVE (char*)(g_err_str[21])
+
+/* comple data type numbers */
+#define CMPDATA_RESERVED 0
+#define CMPDATA_USEVAR   1
+
+/* 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 9 (valid for 32 bits)
+#define div9_32(x) div32(x,0xe38e38e4,35)
+#define rem9_32(x) ((x)-9*div9_32(x))
+
+// 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))

--- mips/trunk/megalopa/function.c	(nonexistent)
+++ mips/trunk/megalopa/function.c	(revision 268)
@@ -0,0 +1,588 @@
+/*
+   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(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020003; //ori         v0,zero,0x03
+	} else {
+		err=get_value();
+		if (err) return err;
+	}
+	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++]=0xAFA20004; // sw          v0,4(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++]=0xAFA20008; // sw          v0,8(sp)
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_STRNCMP);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	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;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_FLOAT);
+	return 0;
+}
+
+char* valsharp_function(void){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_VALSHARP);
+	return 0;
+}
+
+char* int_function(void){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_INT);
+	return 0;
+}
+
+char* fseek_function(){
+	call_lib_code(LIB_FILE | FUNC_FTELL);
+	return 0;
+}
+
+char* flen_function(){
+	call_lib_code(LIB_FILE | FUNC_FLEN);
+	return 0;
+}
+
+char* fgetc_function(){
+	call_lib_code(LIB_FILE | FUNC_FGETC);
+	return 0;
+}
+
+char* finput_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]!=')') {
+		err=get_value();
+		if (err) return err;
+	} else {
+		// Parameter will be zero if not defined
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; // ori v0,zero,0
+	}
+	call_lib_code(LIB_FILE | FUNC_FINPUT);
+	return 0;
+}
+
+char* feof_function(){
+	call_lib_code(LIB_FILE | FUNC_FEOF);
+	return 0;
+}
+
+char* playwave_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]!=')') {
+		// Get param
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_PLAYWAVEFUNC);
+	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;
+	call_lib_code(LIB_FLOATFUNCS | func);
+	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(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_FLOATFUNCS | func);
+	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("ATAN2#(")) {
+		err=float_2param_function(FUNC_ATAN2);
+	} 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;
+}
+
+static const void* str_func_list[]={
+	"CHR$(",chr_function,
+	"HEX$(",hex_function,
+	"DEC$(",dec_function,
+	"INPUT$(",input_function,
+	"GOSUB$(",gosub_function,
+	"ARGS$(",args_function,
+	"READ$(",read_function,
+	"SPRINTF$(",sprintf_function,
+	"FLOAT$(",floatstr_function,
+	"SYSTEM$(",system_function,
+	"FINPUT$(",finput_function,
+	// Additional functions follow
+	ADDITIONAL_STR_FUNCTIONS
+};
+
+char* str_function(void){
+	char* err;
+	int i;
+	char* (*f)();
+	// Seek the function
+	for (i=0;i<sizeof(str_func_list)/sizeof(str_func_list[0]);i+=2){
+		if (nextCodeIs((char*)str_func_list[i])) break;
+	}
+	if (i<sizeof(str_func_list)/sizeof(str_func_list[0])) {
+		// Function found. Call it.
+		f=str_func_list[i+1];
+		err=f();
+	} else {
+		return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+// Aliases follow
+
+char* gcolor_function(){
+	return graphic_statement(FUNC_GCOLOR);
+}
+
+char* fopen_function(){
+	return fopen_statement_main(FUNC_FOPEN);
+}
+
+static const void* int_func_list[]={
+	"NOT(",not_function,
+	"DRAWCOUNT(",drawcount_function,
+	"MUSIC(",music_function,
+	"TVRAM(",tvram_function,
+	"KEYS(",keys_function,
+	"READ(",read_function,
+	"CREAD(",cread_function,
+	"GOSUB(",gosub_function,
+	"STRNCMP(",strncmp_function,
+	"PEEK(",peek_function,
+	"LEN(",len_function,
+	"ASC(",asc_function,
+	"SGN(",sgn_function,
+	"ABS(",abs_function,
+	"RND(",rnd_function,
+	"VAL(",val_function,
+	"INKEY(",inkey_function,
+	"ARGS(",args_function,
+	"SYSTEM(",system_function,
+	"INT(",int_function,
+	"GCOLOR(",gcolor_function,
+	"FOPEN(",fopen_function,
+	"FSEEK(",fseek_function,
+	"FLEN(",flen_function,
+	"FGET(",fget_statement,
+	"FPUT(",fput_statement,
+	"FGETC(",fgetc_function,
+	"FPUTC(",fputc_statement,
+	"FREMOVE(",fremove_statement,
+	"FEOF(",feof_function,
+	"PLAYWAVE(",playwave_function,
+	// Additional functions follow
+	ADDITIONAL_INT_FUNCTIONS
+};
+
+char* function(void){
+	char* err;
+	int i;
+	char* (*f)();
+	// Seek the function
+	for (i=0;i<sizeof(int_func_list)/sizeof(int_func_list[0]);i+=2){
+		if (nextCodeIs((char*)int_func_list[i])) break;
+	}
+	if (i<sizeof(int_func_list)/sizeof(int_func_list[0])) {
+		// Function found. Call it.
+		f=int_func_list[i+1];
+		err=f();
+	} else {
+		return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}

--- mips/trunk/megalopa/library.c	(nonexistent)
+++ mips/trunk/megalopa/library.c	(revision 268)
@@ -0,0 +1,1085 @@
+/*
+   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;
+				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 (including temporary and permanent ones) will be integer 0
+	for(i=0;i<ALLOC_BLOCK_NUM;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;
+	// Stop using graphic
+	g_use_graphic=1; // Force set_graphmode(0) (see usegraphic() function)
+	usegraphic(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:
+			// ,
+			printcomma();
+			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;
+	keys=readbuttons();
+	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_usegraphic(int mode){
+	usegraphic(mode);
+	// Move current point to (0,0)
+	g_prev_x=g_prev_y=0;
+}
+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();
+		}
+	}
+}
+
+int lib_graphic(int v0,enum functions func){
+	unsigned char b;
+	int x1=g_libparams[1];
+	int y1=g_libparams[2];
+	int x2=g_libparams[3];
+	int y2=g_libparams[4];
+	// Disable if graphic area is not defined.
+	if (!g_graphic_area) return;
+	// If C is omitted in parameters, use current color.
+	if (v0==-1) {
+		v0=g_gcolor;
+	}
+	// If X1 or Y1 is 0x80000000, use the previous values.
+	if (x1==0x80000000) x1=g_prev_x;
+	if (y1==0x80000000) 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);
+			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);
+			else g_gline(x1,y1,x2,y2,v0);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_BOXFILL:// X1,Y1,X2,Y2[,C]
+			g_boxfill(x1,y1,x2,y2,v0);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_CIRCLE:// X1,Y1,R[,C]
+			g_circle(x1,y1,x2,v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_CIRCLEFILL:// X1,Y1,R[,C]
+			g_circlefill(x1,y1,x2,v0);
+			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 a0, int a1, int* sp){
+	// Note that sp[1] is used for string return address
+	// sp[2] can be used to store flags
+	// sp[3] etc can be used to store variable values
+	int i,params;
+	unsigned char varnum;
+	unsigned int strflags=0;
+	int stack=3;
+	for(i=0;i<8;i++){
+		// Prepare parameter
+		switch(i){
+			case 0:
+				params=a0;
+				break;
+			case 4:
+				params=a1;
+				break;
+			default:
+				break;
+		}
+		// Get variable number
+		varnum=params&0xff;
+		params>>=8;
+		if (varnum==0) break; // No more variable. End the loop.
+		varnum--;
+		sp[stack++]=g_var_mem[varnum];
+		if (g_var_size[varnum] && g_var_mem[varnum]==(int)(&g_var_pointer[varnum])) {
+			// strflags change using varnum
+			strflags|=1<<i;
+			// Copy to VAR_BLOCK
+			move_to_perm_block(varnum);
+		}
+		// Clear variable
+		g_var_mem[varnum]=0;
+	}
+	// Store string flags
+	sp[2]=strflags;
+}
+
+void lib_var_pop(int a0, int a1, int* sp){
+	// Note that sp is 4 bytes larger than that in lib_var_push
+	// sp[1] was used to store flags
+	// sp[2] etc can be used to store variable values
+	int i,params;
+	unsigned char varnum;
+	int stack=2;
+	unsigned int strflags=sp[1];
+	for(i=0;i<8;i++){
+		// Prepare parameter
+		switch(i){
+			case 0:
+				params=a0;
+				break;
+			case 4:
+				params=a1;
+				break;
+			default:
+				break;
+		}
+		// Get variable number
+		varnum=params&0xff;
+		params>>=8;
+		if (varnum==0) break; // No more variable. End the loop.
+		varnum--;
+		g_var_mem[varnum]=sp[stack++];
+		if (strflags&(1<<i)) {
+			// Restore from VAR_BLOCK
+			move_from_perm_block(varnum);
+		}
+	}
+}
+
+
+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_ATAN2:
+			v0=atan2f(v0,a0);
+			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 lib_file_textlen(FSFILE* fhandle){
+	char buff[128];
+	int i,textlen,len,seek;
+	seek=FSftell(fhandle);
+	len=FSfread(&buff[0],1,128,fhandle);
+	textlen=0;
+	for(i=0;i<len-1;i++){ // Read 127 bytes for supporting CRLF
+		if (buff[i]==0x0d) {
+			if (i<len && buff[i+1]==0x0a) i++;
+			break;
+		} else if (buff[i]==0x0a) {
+			break;
+		}
+		if (i==len-2) {
+			// reached the end of buffer. Read next 127 bytes
+			textlen+=127;
+			buff[0]=buff[127];
+			len=FSfread(&buff[1],1,127,fhandle);
+			// Continue with i=0
+			i=-1;
+		}
+	}
+	// The last return code must be included to caluclate total length.
+	textlen+=i+1;
+	// Return to original position
+	FSfseek(fhandle,seek,SEEK_SET);
+	return textlen;
+}
+
+int lib_file(enum functions func, int a0, int a1, int v0){
+	static FSFILE* s_fhandle[2]={0,0};
+	static char activefhandle=0;
+	static int numinline=0;
+	FSFILE* fhandle=0;
+	int i;
+	int buff[1];
+	char* str;
+	if (activefhandle) fhandle=s_fhandle[activefhandle-1];
+	switch(func){
+		case FUNC_FINIT:
+			// This function is not BASIC statement/function but used from
+			// running routine. 
+			for(i=0;i<2;i++){
+				if (s_fhandle[i]) FSfclose(s_fhandle[i]);
+				s_fhandle[i]=0; 
+			}
+			activefhandle=0;
+			numinline=0;
+			break;
+		case FUNC_FOPEN:   // Return 0 when called as a function.
+		case FUNC_FOPENST: // Stop with error when called as a statement.
+			activefhandle=0;
+			// Check if file handle is free to use, first.
+			switch(v0){
+				case 0:
+					// File handle was not designated
+					// Force handle=1 and continue to following cases.
+					v0=1;
+				case 1:
+				case 2:
+					// File handle was designated
+					// Check if not used yet.
+					if (s_fhandle[v0-1]) {
+						// This file handle has been occupied.
+						err_file();
+						return 0;
+					}
+					// OK. This file handle can be asigned for new file opened.
+					break;
+				default:
+					err_invalid_param();
+					return 0;
+			}
+			// Open a file
+			fhandle=FSfopen ((const char*) a0, (const char*) a1);
+			if (!fhandle) {
+				if (func==FUNC_FOPENST) err_file();
+				return 0;
+			}
+			// The file is succesfully opened. Asign file handle.
+			s_fhandle[v0-1]=fhandle;
+			activefhandle=v0;
+			return v0;
+		case FUNC_FILE:
+			switch(v0){
+				case 1:
+				case 2:
+					if (s_fhandle[v0]) {
+						activefhandle=v0;
+						break;
+					}
+				default:
+					err_invalid_param();
+			}
+			break;
+		case FUNC_FCLOSE:
+			switch(v0){
+				case 0:
+					break;
+				case 1:
+				case 2:
+					if (s_fhandle[v0-1]) activefhandle=v0;
+					if (activefhandle) fhandle=s_fhandle[activefhandle-1];
+					break;
+				default:
+					err_invalid_param();
+			}
+			if (fhandle) {
+				FSfclose(fhandle);
+				s_fhandle[activefhandle-1]=0;
+			}
+			activefhandle=0;
+			break;	
+		case FUNC_FINPUT:
+			if (fhandle) {
+				// Determine text length if called without parameter
+				if (v0==0) v0=lib_file_textlen(fhandle);
+				// Allocate temporary area for string
+				str=alloc_memory((v0+1+3)/4,-1);
+				// Read from SD card
+				v0=FSfread(str,1,v0,fhandle);
+				// Null string at the end.
+				str[v0]=0;
+				return (int)str;
+			} else {
+				err_file();
+				return (int)"";
+			}
+		case FUNC_FPRINTSTR:
+			// Like lib_printstr()
+			for(i=0;((char*)v0)[i];i++);
+			if (fhandle) {
+				if (!FSfwrite((char*)v0,1,i,fhandle)) err_file();
+			} else err_file();
+			numinline+=i;
+			break;
+		case FUNC_FSTRING:
+			// Like lib_string()
+			switch(v0){
+				case 0:
+					// CR
+					lib_file(FUNC_FPRINTSTR,a0,a1,(int)"\r\n");
+					numinline=0;
+					break;
+				case 1:
+					// ,
+					i=rem10_32(numinline);
+					lib_file(FUNC_FPRINTSTR,a0,a1,(int)("          "+i));
+					break;
+				default:
+					break;
+			}
+			break;
+		case FUNC_FGET:
+			if (fhandle) return FSfread((void*)a0,1,v0,fhandle);
+			err_file();
+			break;
+		case FUNC_FPUT:
+			if (fhandle) return FSfwrite((void*)a0,1,v0,fhandle);
+			err_file();
+			break;
+		case FUNC_FGETC:
+			if (fhandle) {
+				// Note: Little endian.
+				if (FSfread((void*)&buff[0],1,1,fhandle)) return buff[0]&0xff;
+				else return -1;
+			}
+			err_file();
+			break;
+		case FUNC_FPUTC:
+			if (fhandle) {
+				// Note: Little endian.
+				buff[0]=v0;
+				return FSfwrite((void*)&buff[0],1,1,fhandle);
+			}
+			err_file();
+			break;
+		case FUNC_FSEEK:
+			if (fhandle) return FSfseek(fhandle,v0,SEEK_SET);
+			err_file();
+			break;
+		case FUNC_FTELL:
+			if (fhandle) return FSftell(fhandle);
+			err_file();
+			break;
+		case FUNC_FLEN:
+			if (fhandle) return fhandle->size;
+			err_file();
+			break;
+		case FUNC_FEOF:
+			if (fhandle) return (fhandle->size<=FSftell(fhandle)) ? 1:0;
+			err_file();
+			break;
+		case FUNC_FREMOVE:
+			return FSremove((const char *)v0);
+		default:
+			err_unknown();
+	}
+	return v0;
+}
+
+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");
+	// Store sp in g_libparams
+	asm volatile("la $v0,%0"::"i"(&g_libparams));
+	asm volatile("sw $sp,0($v0)");
+	// Jump to main routine
+	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 & LIB_MASK){
+		case LIB_FLOAT:
+			return lib_float(a0,v0,(enum operator)(a3 & OP_MASK)); // see operator.c
+		case LIB_FLOATFUNCS:
+			return lib_floatfuncs(a0,v0,(enum functions)(a3 & FUNC_MASK));
+		case LIB_STRNCMP:
+			return strncmp((char*)g_libparams[1],(char*)g_libparams[2],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(v0);
+			return v0;
+		case LIB_PRINTSTR:
+			printstr((char*)v0);
+			return v0;
+		case LIB_GRAPHIC:
+			return lib_graphic(v0, (enum functions)(a3 & FUNC_MASK));
+		case LIB_SPRINTF:
+			return (int)lib_sprintf((char*)v0,a0);
+		case LIB_VAR_PUSH:
+			lib_var_push(a0,a1,g_libparams);
+			return v0;
+		case LIB_VAR_POP:
+			lib_var_pop(a0,a1,g_libparams);
+			return v0;
+		case LIB_SCROLL:
+			scroll(g_libparams[1],v0);
+			return v0;
+		case LIB_FILE:
+			return lib_file((enum functions)(a3 & FUNC_MASK),g_libparams[1],g_libparams[2],v0);
+		case LIB_KEYS:
+			return lib_keys(v0);
+		case LIB_INKEY:
+			return (int)lib_inkey(v0);
+		case LIB_CURSOR:
+			setcursor(g_libparams[1],v0,cursorcolor);
+			return v0;
+		case LIB_SOUND:
+			set_sound((unsigned long*)v0,a0);
+			return v0;
+		case LIB_MUSICFUNC:
+			return musicRemaining(a0);
+		case LIB_MUSIC:
+			set_music((char*)v0,a0);
+			return v0;
+		case LIB_PLAYWAVE:
+			play_wave((char*)g_libparams[1],v0);
+			return v0;
+		case LIB_PLAYWAVEFUNC:
+			return waveRemaining(v0);
+		case LIB_SETDRAWCOUNT:
+			drawcount=(v0&0x0000FFFF);
+			return v0;
+		case LIB_DRAWCOUNT:
+			return drawcount;
+		case LIB_SYSTEM:
+			return lib_system(a0, a1 ,v0, a3, g_gcolor, g_prev_x, g_prev_y);
+		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(g_libparams[1],g_libparams[2],v0);
+			return v0;
+		case LIB_BGCOLOR: // BGCOLOR R,G,B
+			set_bgcolor(v0,g_libparams[1],g_libparams[2]); //set_bgcolor(b,r,g);
+			return v0;
+		case LIB_PALETTE: // PALETTE N,R,G,B
+			set_palette(g_libparams[1],v0,g_libparams[2],g_libparams[3]); // set_palette(n,b,r,g);
+			return v0;
+		case LIB_GPALETTE:// GPALETTE N,R,G,B
+			if (g_graphic_area) g_set_palette(g_libparams[1],v0,g_libparams[2],g_libparams[3]); // 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_WIDTH:
+			videowidth(v0);
+			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/trunk/megalopa/statement.c	(nonexistent)
+++ mips/trunk/megalopa/statement.c	(revision 268)
@@ -0,0 +1,1637 @@
+/*
+   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);
+	}
+	// 2nd param is optional
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		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++]=0x00402021; // addu        a0,v0,zero
+		g_object[g_objpos++]=0x8FA20004; // lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	} else {
+		// Set 3 if omitted
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040003; // addiu       a0,zero,xx
+	}
+	call_lib_code(LIB_SOUND);
+	return 0;
+}
+char* music_statement(){
+	char *err;
+	err=get_string();
+	if (err) return err;
+	// 2nd param is optional
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		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++]=0x00402021; // addu        a0,v0,zero
+		g_object[g_objpos++]=0x8FA20004; // lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	} else {
+		// Set 3 if omitted
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040003; // addiu       a0,zero,xx
+	}
+	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]==',') {
+				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 i;
+	int spos;
+	int stack;
+	while(1){
+		stack=0;
+		next_position();
+		i=get_var_number();
+		if (i<0) return ERR_SYNTAX;
+		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|(i);       // 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++]=0x04130003;                            // bgezall     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++]=0x04130003; // bgezall     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
+	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
+	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
+	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(int i){
+	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|(i*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 b2,b3;
+	int i;
+	next_position();
+	i=get_var_number();
+	if (i<0) return ERR_SYNTAX;
+	b2=g_source[g_srcpos];
+	b3=g_source[g_srcpos+1];
+	if (b2=='#' && b3=='(') {
+		// Float dimension
+		g_srcpos++;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+		let_dim_sub(i);
+		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|(i*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|(i);          //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(i);
+		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|(i*4);        // sw v0,xxx(s8)
+	}
+	return 0;
+}
+
+char* print_statement_main(enum libs lib_printstr, enum libs lib_string){
+	char* err;
+	char b1;
+	int i;
+	int status=0;// 1:',' 2:';' 0:none
+	while(1){
+		next_position();
+		if (endOfStatement()) 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++]=0x34020001;                      // ori   v0,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++]=0x34020000;                      // ori   v0,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* continue_statement(){
+	check_obj_space(2);
+	g_object[g_objpos++]=0x08160008; // j           xxxx     (See link() function)
+	g_object[g_objpos++]=0x00000000; // nop
+	return 0;
+}
+
+char* for_statement(){
+	char* err;
+//	char b1;
+	int i;
+	int prepos=g_srcpos;
+	// Initialization of variable
+//	next_position();
+//	b1=g_source[g_srcpos];
+	i=get_var_number();
+//	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX;
+	if (i<0) return ERR_SYNTAX;
+	g_srcpos=prepos;
+	err=let_statement();
+	if (err) return err;
+	// Check if "TO" exists
+	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
+	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++]=0x04130004;              // bgezall     zero,check
+//	g_object[g_objpos++]=0x8FC40000|((b1-'A')*4); // lw          a0,xx(s8)      (current var value)
+	g_object[g_objpos++]=0x8FC40000|(i*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++]=0x8FC40000|(i*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)
+	g_object[g_objpos++]=0xAFC40000|(i*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)
+	// Following assembly must be 4 words.
+	// If the number of words will be changed, link.c must be reviced for CONTINUE 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++]=0x04130001;//   bgezall     zero,label1:
+	g_object[g_objpos++]=0x0822FFFC;//   addiu       sp,sp,-4 (see linker)
+	                                //   label1:
+	g_object[g_objpos++]=0xAFBF0004;//   sw          ra,4(sp)
+	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;
+	int opos;
+	opos=g_objpos;
+	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
+	opos=g_objpos+1-opos;
+	g_object[g_objpos++]=0x3000F000|opos; // nop                 (See linker, used for CONTINUE statement)
+	                                      // 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++]=0x04130001; // bgezall     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++]=0x3000F003; // nop                 (See linker, used for CONTINUE statement)
+	                                 // label1:
+	g_object[g_objpos++]=0x08310004; // addiu       sp,sp,4 (See link() function)
+	return 0;
+}
+
+char* param4_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++]=0xAFA20004; // sw          v0,4(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++]=0xAFA2000C; // sw          v0,12(sp)
+	// Get B
+	err=get_value();
+	if (err) return err;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD000C; // addiu       sp,sp,12
+	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++]=0xAFA20004; // sw          v0,4(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++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd parameter
+	err=get_value();
+	if (err) return err;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	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;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	return 0;
+}
+
+char* system_statement(){
+	// SYSTEM X,Y
+	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_SYSTEM);
+	return 0;
+}
+
+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* width_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_WIDTH);
+	return 0;
+}
+
+char* var_statement_sub(int a0, int a1){
+	// Construct parameter-setting scripts
+	if (a0&0xffff0000) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3C040000|(a0>>16);        // lui         a0,XXXX
+		if (a0&0x0000ffff) {
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34840000|(a0&0xffff); // ori         a0,a0,XXXX
+		}
+	} else if (a0&0x0000ffff) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34040000|(a0&0xffff);     // ori         a0,zero,xxxx
+	}
+	if (a1&0xffff0000) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3C050000|(a1>>16);        // lui         a1,XXXX
+		if (a1&0x0000ffff) {
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34A50000|(a1&0xffff); // ori         a1,a1,XXXX
+		}
+	} else if (a1&0x0000ffff) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34050000|(a1&0xffff);     // ori         a1,zero,xxxx
+	} else if (a0&0xff000000) {
+		// # of variables is 4. Reset $a1 to let lib_var() know that there is no more variables to store.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34050000;                 // ori         a1,zero,0
+	}
+	return 0;
+}
+
+char* var_statement(){
+	char* err;
+	int i,j,a0,a1;
+	static int prevpos;
+	short stack;
+	do {
+		// For stack, 4 bytes are used for return address,
+		// 4 bytes are used in lib_var(),
+		// and additinal bytes are used for storing variable values.
+		stack=8;
+		a0=a1=0;
+		for (i=0;i<8;i++){
+			// Determine the variable number from source code
+			j=get_var_number();
+			if (j<0) return ERR_SYNTAX;
+			stack+=4;
+			// Create parameters in $a0, or $a1
+			if (i<4) {
+				a0=(a0<<8)|(j+1);
+			} else {
+				a1=(a1<<8)|(j+1);
+			}
+			// Check remaining variable(s) 
+			if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') g_srcpos++;
+			next_position();
+			if (g_source[g_srcpos]!=',') break;
+			g_srcpos++;
+		}
+		// Jump to push routine, first
+		check_obj_space(2);
+		prevpos=g_objpos;
+		g_object[g_objpos++]=0x04130000;                    // bgezall     zero,label1
+		g_object[g_objpos++]=0x27BD0000|((0-stack)&0xffff); // addiu       sp,sp,-xx
+		// Process will be here after RETURN statement
+		// Pop routine
+		err=var_statement_sub(a0,a1);                       // Prepare a0, and a1
+		if (err) return err;
+		call_lib_code(LIB_VAR_POP);
+		// Restore stack and return
+		check_obj_space(3);
+		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
+		g_object[prevpos]|=g_objpos-prevpos-1;              // label1:
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFBF0004;                    // sw          ra,4(sp)
+		err=var_statement_sub(a0,a1);                       // Prepare a0, and a1
+		if (err) return err;
+		call_lib_code(LIB_VAR_PUSH);
+
+	} while (g_source[g_srcpos-1]==',');
+	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
+		4(sp): X1
+		8(sp): Y1
+		12(sp): X2/R/M
+		16(sp): Y2/N
+		v0: C/S$/BMP
+	*/
+	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 0x80000000 for both.
+		check_obj_space(4);
+		g_object[g_objpos++]=0x27BDFFF0;              // addiu       sp,sp,-16
+		g_object[g_objpos++]=0x3C028000;              // lui         v0,0x0080
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+		g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(sp)
+	} else {
+		// X1
+		err=get_value();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFF0;              // addiu       sp,sp,-16
+		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(1);
+		g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(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(1);
+		g_object[g_objpos++]=0xAFA2000C;          // sw          v0,12(sp)
+		if (3<paramnum) {
+			// Y2, BC, or N
+			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++]=0xAFA20010;      // sw          v0,16(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
+		}
+	}
+	// Call library
+	call_lib_code(LIB_GRAPHIC | func);
+	// Restore stack pointer
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0010;              // addiu       sp,sp,16
+	return 0;
+}
+
+char* fopen_statement_main(enum functions func){
+	// func is either FUNC_FOPENST or FUNC_FOPEN
+	char* err;
+	// Get 1st
+	err=get_string();
+	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++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If 3rd parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_FILE | func);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+
+char* file_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FILE);
+	return 0;
+}
+
+char* fclose_statement(){
+	char* err;
+	int orgpos=g_srcpos;
+	if (endOfStatement()) {
+		// If no argument, use 0
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	} else {
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_FILE | FUNC_FCLOSE);
+	return 0;
+}
+
+char* fget_statement(){
+	return param2_statement(LIB_FILE | FUNC_FGET);
+}
+
+char* fput_statement(){
+	return param2_statement(LIB_FILE | FUNC_FPUT);
+}
+
+char* fseek_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FSEEK);
+	return 0;
+}
+
+char* fputc_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FPUTC);
+	return 0;
+}
+
+char* fremove_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FREMOVE);
+	return 0;
+}
+
+char* usevar_statement(){
+	char* err;
+	int i;
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		err=register_var_name(i);
+		if (err) return err;
+		if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+char* playwave_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		// Get 2nd
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If 2rd parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_PLAYWAVE);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	return 0;
+}
+
+#ifdef __DEBUG
+	char* debug_statement(){
+		call_lib_code(LIB_DEBUG);
+		return 0;
+	}
+#endif
+
+// Aliases follow
+
+char* palette_statement(){
+	return param4_statement(LIB_PALETTE);
+}
+
+char* gpalette_statement(){
+	return param4_statement(LIB_GPALETTE);
+}
+
+char* print_statement(){
+	return print_statement_main(LIB_PRINTSTR,LIB_STRING);
+}
+
+char* pset_statement(){
+	return graphic_statement(FUNC_PSET);
+}
+
+char* line_statement(){
+	return graphic_statement(FUNC_LINE);
+}
+
+char* boxfill_statement(){
+	return graphic_statement(FUNC_BOXFILL);
+}
+
+char* circle_statement(){
+	return graphic_statement(FUNC_CIRCLE);
+}
+
+char* circlefill_statement(){
+	return graphic_statement(FUNC_CIRCLEFILL);
+}
+
+char* gprint_statement(){
+	return graphic_statement(FUNC_GPRINT);
+}
+
+char* putbmp_statement(){
+	return graphic_statement(FUNC_PUTBMP);
+}
+
+char* point_statement(){
+	return graphic_statement(FUNC_POINT);
+}
+
+char* fopen_statement(){
+	return fopen_statement_main(FUNC_FOPENST);
+}
+
+char* fprint_statement(){
+	return print_statement_main(LIB_FILE | FUNC_FPRINTSTR,LIB_FILE | FUNC_FSTRING);
+}
+
+static const void* statement_list[]={
+	"REM",rem_statement,
+	"SOUND ",sound_statement,
+	"MUSIC ",music_statement,
+	"DRAWCOUNT ",drawcount_statement,
+	"CURSOR ",cursor_statement,
+	"PALETTE ",palette_statement,
+	"GPALETTE ",gpalette_statement,
+	"BGCOLOR ",bgcolor_statement,
+	"CLS",cls_statement,
+	"GCLS",gcls_statement,
+	"COLOR ",color_statement,
+	"GCOLOR ",gcolor_statement,
+	"RESTORE ",restore_statement,
+	"DATA ",data_statement,
+	"CDATA ",cdata_statement,
+	"LABEL ",label_statement,
+	"DIM ",dim_statement,
+	"CLEAR",clear_statement,
+	"PRINT",print_statement,
+	"IF ",if_statement,
+	"ELSEIF ",elseif_statement,
+	"ELSE",else_statement,
+	"ENDIF",endif_statement,
+	"END",end_statement,
+	"EXEC ",exec_statement,
+	"GOTO ",goto_statement,
+	"GOSUB ",gosub_statement,
+	"RETURN",return_statement,
+	"POKE ",poke_statement,
+	"FOR ",for_statement,
+	"NEXT",next_statement,
+	"LET ",let_statement,
+	"PCG ",pcg_statement,
+	"USEPCG",usepcg_statement,
+	"SCROLL ",scroll_statement,
+	"WAIT ",wait_statement,
+	"USEGRAPHIC",usegraphic_statement,
+	"PSET ",pset_statement,
+	"LINE ",line_statement,
+	"BOXFILL ",boxfill_statement,
+	"CIRCLE ",circle_statement,
+	"CIRCLEFILL ",circlefill_statement,
+	"GPRINT ",gprint_statement,
+	"PUTBMP ",putbmp_statement,
+	"POINT ",point_statement,
+	"VAR ",var_statement,
+	"DO",do_statement,
+	"LOOP",loop_statement,
+	"WHILE ",while_statement,
+	"WEND",wend_statement,
+	"BREAK",break_statement,
+	"CONTINUE",continue_statement,
+	"SYSTEM",system_statement,
+	"WIDTH ",width_statement,
+	"FOPEN ",fopen_statement,
+	"FILE ",file_statement,
+	"FCLOSE",fclose_statement,
+	"FPRINT ",fprint_statement,
+	"FGET ",fget_statement,
+	"FPUT ",fput_statement,
+	"FPUTC ",fputc_statement,
+	"FSEEK ",fseek_statement,
+	"FREMOVE ",fremove_statement,
+	"USEVAR ",usevar_statement,
+	"PLAYWAVE ",playwave_statement,
+	// List of additional statements follows
+	ADDITIONAL_STATEMENTS
+};
+
+char* statement(void){
+	char* err;
+	int prevpos;
+	int i;
+	char* (*f)();
+	// Clear flag for temp area usage.
+	g_temp_area_used=0;
+	// Initialize stack handler used for value
+	g_sdepth=g_maxsdepth=0;
+	// Seek the statement
+	for (i=0;i<sizeof(statement_list)/sizeof(statement_list[0]);i+=2){
+		if (nextCodeIs((char*)statement_list[i])) break;
+	}
+	if (i<sizeof(statement_list)/sizeof(statement_list[0])) {
+		// Statement found. Call it.
+		f=statement_list[i+1];
+		err=f();
+#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/trunk/megalopa/error.c	(nonexistent)
+++ mips/trunk/megalopa/error.c	(revision 268)
@@ -0,0 +1,170 @@
+/*
+   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 ",
+	"Invalid parameter(s)",
+	"File error",
+	"Invalid variable name",
+	"WAVE format error",
+};
+
+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];
+	// Cool down the system
+	stop_music();
+	// Resolve line and show it
+	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){
+	stop_music();
+	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){
+	asm volatile("la $v0,%0"::"i"(&g_temp));
+	asm volatile("sw $ra,0($v0)");
+	printstr(ERR_UNKNOWN);
+	printhex32(g_temp);
+	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();	
+}
+
+void err_invalid_param(void){
+	printstr(ERR_INVALID_PARAM);
+	end_exec();	
+}
+
+void err_file(void){
+	printstr(ERR_FILE);
+	end_exec();	
+}
+
+void err_wave(void){
+	printstr(ERR_WAVE);
+	end_exec();	
+}
+

--- mips/trunk/megalopa/debug.h	(nonexistent)
+++ mips/trunk/megalopa/debug.h	(revision 268)
@@ -0,0 +1,30 @@
+/*
+   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 asm("wait") but use asm("nop")
+#undef WAIT
+#define WAIT "nop"
+
+#endif // __DEBUG
+
+// key waiting macro
+
+#define debug_wait() lineinput((char*)&g_temp,3)
+#define debug_wait_char(x) do {\
+		printchar(x); \
+		lineinput((char*)&g_temp,3);\
+	} while(0)	

--- mips/trunk/megalopa/editor.c	(nonexistent)
+++ mips/trunk/megalopa/editor.c	(revision 268)
@@ -0,0 +1,2554 @@
+/*
+   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; //範囲選択時のカーソルスタート座標
+int line_no; //現在のカーソル位置の行
+int line_no1; //範囲選択時のカーソルスタート位置の行
+
+// カーソル関連位置の一時避難用
+_tbuf *cursorbp_t;
+unsigned short cursorix_t;
+_tbuf *disptopbp_t;
+unsigned short disptopix_t;
+int cx_t,cy_t,line_no_t;
+
+//unsigned char clipboard[WIDTH_XMAX*EDITWIDTHY]; //クリップボード、最大サイズは編集画面領域と同じ
+unsigned char *clipboard; //実体は配列RAM[]の中に確保する
+
+int clipsize; //現在クリップボードに格納されている文字数
+int edited; //保存後に変更されたかを表すフラグ
+
+//配列RAM[]内にメモリ動的確保するためのポインタ
+char *editormallocp;
+
+//unsigned char filebuf[FILEBUFSIZE]; //ファイルアクセス用バッファ
+unsigned char *filebuf; //実体は配列RAM[]の中に確保する
+
+//unsigned char cwdpath[PATHNAMEMAX]; //現在のディレクトリのパス名
+unsigned char *cwdpath; //実体は配列RAM[]の中に確保する
+
+unsigned char currentfile[13],tempfile[13]; //編集中のファイル名、一時ファイル名
+
+//unsigned char filenames[MAXFILENUM][13]; //ロード時のファイル名一覧バッファ
+unsigned char (*filenames)[13]; //実体は配列RAM[]の中に確保する
+
+//unsigned char undobuf[UNDOBUFSIZE]; //アンドゥ用バッファ
+unsigned char *undobuf; //実体は配列RAM[]の中に確保する
+unsigned char *undobuf_top; //アンドゥ用バッファの先頭を指すポインタ
+int undobuf_used; //アンドゥ用バッファ使用量
+
+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";
+const unsigned char ROOTDIR[]="\\";
+
+unsigned char * editormalloc(int size){
+//配列RAM[]内にサイズsizeの領域を確保し、先頭アドレスを返す
+//確保できない場合は、エラー表示し動作停止
+	unsigned char *p;
+	if(editormallocp+size>RAM+RAMSIZE){
+		printstr("Cannot allocate memory");
+		while(1) asm("wait");
+	}
+	p=editormallocp;
+	editormallocp+=size;
+	return p;
+}
+
+void wait60thsec(unsigned short n){
+#ifndef __DEBUG
+	// 60分のn秒ウェイト（ビデオ画面の最下行信号出力終了まで待つ）
+	n+=drawcount;
+	while(drawcount!=n) asm(WAIT);
+#else
+	// DEBUGモードでは、待ち時間無し
+	drawcount+=n;
+#endif
+}
+
+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;
+}
+
+// アンドゥバッファ
+/*
+UNDOBUFSIZEバイトの環状バッファ。テキストバッファに対する変更発生ごとに、
+変更内容、変更場所をバッファの先頭に記録し、先頭位置を進める。
+アンドゥ実行が呼び出されると、バッファ先頭から読み出し、テキストバッファに対して
+元に戻す変更を行う。
+バッファがいっぱいになると、最後尾から消去（上書き）していく。
+
+＜バッファ仕様＞
+　開始位置：テキストバッファトップから何バイト目か（2バイト。下位、上位の順）
+　繰り返し数：連続動作の場合の回数（2バイト。下位、上位の順）
+　バッファの前からも後ろからも削除できるよう、先頭と最後に命令をおく。ただし、
+　後ろの命令コードが10以上の場合は削除された文字そのものを意味する。
+1文字挿入
+　UNDO_INSERT,開始位置,UNDO_INSERT
+1文字上書き
+　UNDO_OVERWRITE,開始位置,消去文字 [,消去文字が0?9の場合さらに0を付加]
+1文字削除（Delete）
+　UNDO_DELETE,開始位置,消去文字 [,消去文字が0?9の場合さらに0を付加]
+1文字削除（BackSpace）
+　UNDO_BACKSPACE,開始位置,消去文字 [,消去文字が0?9の場合さらに0を付加]
+連続挿入（Ctrl+Vで貼り付け）
+　UNDO_CONTINS,開始位置,繰り返し数,UNDO_CONTINS
+連続削除（領域選択して削除）
+　UNDO_CONTDEL,繰り返し数,消去文字列,開始位置,繰り返し数,UNDO_CONTDEL
+*/
+
+void pushundomem(unsigned char c){
+// アンドゥ用メモリの先頭に1バイトを貯める
+// 空きがなくなった場合、最後尾の1命令分を無効化
+	unsigned char *p;
+	int n;
+
+	if(undobuf_used>=UNDOBUFSIZE){
+	//空きがない場合、最後尾のブロックのバイト数分をバッファ利用済み量から減らす
+		p=undobuf_top-undobuf_used; //最後尾
+		if(p<undobuf) p+=UNDOBUFSIZE;
+		switch(*p){
+			case UNDO_INSERT: //1文字挿入
+				undobuf_used-=4;
+				break;
+			case UNDO_OVERWRITE: //1文字上書き
+			case UNDO_DELETE: //1文字削除
+			case UNDO_BACKSPACE: //1文字削除（BS）
+				undobuf_used-=4;
+				p+=3;
+				if(p>=undobuf+UNDOBUFSIZE) p-=UNDOBUFSIZE;
+				if(*p<10) undobuf_used--; //コード0?9の場合後ろに0が付加されている
+				break;
+			case UNDO_CONTINS: //連続挿入
+				undobuf_used-=6;
+				break;
+			case UNDO_CONTDEL: //連続削除
+				//繰り返し数の読み出し
+				p++;
+				if(p>=undobuf+UNDOBUFSIZE) p-=UNDOBUFSIZE;
+				n=*p++;
+				if(p>=undobuf+UNDOBUFSIZE) p-=UNDOBUFSIZE;
+				n+=*p<<8;
+				undobuf_used-=n+8;
+				break;
+		}
+	}
+	//アンドゥバッファ先頭に1バイト挿入し、先頭位置を1進める
+	*undobuf_top++=c;
+	if(undobuf_top>=undobuf+UNDOBUFSIZE) undobuf_top-=UNDOBUFSIZE;
+	undobuf_used++;
+}
+void pushundomem2(unsigned short w){
+// アンドゥバッファに2バイト貯める、下位、上位の順
+	pushundomem((unsigned char)w);
+	pushundomem(w>>8);
+}
+unsigned char popundomem(){
+// アンドゥバッファから1バイト読み出し、先頭を1つ戻す
+// 戻り値：読み出したコード
+	undobuf_top--;
+	if(undobuf_top<undobuf) undobuf_top+=UNDOBUFSIZE;
+	undobuf_used--;
+	return *undobuf_top;
+}
+unsigned short popundomem2(){
+// アンドゥバッファから2バイト読み出し
+// 戻り値：読み出した2バイトコード
+	unsigned short w;
+	w=popundomem()<<8;
+	w+=popundomem();
+	return w;
+}
+void setundobuf(int com,_tbuf *bp,unsigned short ix,unsigned char c,unsigned short n){
+//アンドゥバッファにデータをセットする
+//com:コマンド　1:1文字削除、2:1文字上書き、3:1文字挿入、4:連続削除、5:連続挿入開始
+//bp,ix:バッファ上の実行場所（カーソル位置）
+//c:文字（上書き、挿入の場合のみ使用）
+//n:連続数（連続の場合のみ使用）
+	unsigned short pos;
+
+	pos=bpixtopos(bp,ix); //テキストバッファ先頭から何バイト目かを求める
+	switch(com){
+		case UNDO_INSERT: //1文字挿入
+			pushundomem(com);
+			pushundomem2(pos);
+			pushundomem(com);
+			break;
+		case UNDO_OVERWRITE: //1文字上書き
+		case UNDO_DELETE: //1文字削除（Delete）
+		case UNDO_BACKSPACE: //1文字削除（BackSpace）
+			pushundomem(com);
+			pushundomem2(pos);
+			pushundomem(c);
+			if(c<10) pushundomem(0); //10未満のコードの場合0を付加
+			break;
+		case UNDO_CONTINS: //連続挿入
+			pushundomem(com);
+			pushundomem2(pos);
+			pushundomem2(n);
+			pushundomem(com);
+			break;
+		case UNDO_CONTDEL: //連続削除
+			pushundomem(com);
+			pushundomem2(n);
+			break;
+	}
+}
+
+int insertchar(_tbuf *bp,unsigned int ix,unsigned char c,int undo){
+//テキストバッファbpの先頭からixバイトの位置にcを挿入
+//undo 0:通常（アンドゥバッファに格納する）、1:連続挿入中、2:アンドゥ中
+//戻り値　成功：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;
+		if(!undo) setundobuf(UNDO_INSERT,bp,ix,0,0); //アンドゥバッファ設定
+		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,undo);
+		return 0;
+	}
+	p=bp->Buf + TBUFSIZE-1;
+	insertchar(bp->next,0,*p,1); //次の行の先頭に1文字挿入（必ず空きあり）
+	for( ; p > bp->Buf+ix ; p--) *p=*(p-1);
+	*p=c;
+	if(!undo) setundobuf(UNDO_INSERT,bp,ix,0,0); //アンドゥバッファ設定
+	return 0;
+}
+
+int overwritechar(_tbuf *bp,unsigned int ix,unsigned char c,int undo){
+//テキストバッファbpの先頭からixバイトの位置をcで上書き
+//undo 0:通常（アンドゥバッファに格納する）、1:連続中、2:アンドゥ中
+//戻り値　成功：0、不正または容量オーバー：-1、空きがあるはずなのに失敗：1
+
+	//現在のバッファ位置の文字が終端または改行の場合、挿入モード
+	if(ix > bp->n) return -1; //不正指定
+	while(ix >= bp->n){
+		if(bp->next==NULL){
+			//テキスト全体最後尾の場合は挿入
+			return insertchar(bp,ix,c,undo);
+		}
+		bp=bp->next;
+		ix=0;
+	}
+	if(bp->Buf[ix]=='\n') return insertchar(bp,ix,c,undo);
+	if(!undo) setundobuf(UNDO_OVERWRITE,bp,ix,bp->Buf[ix],0); //アンドゥバッファ設定
+	bp->Buf[ix]=c;
+	return 0;
+}
+
+void deletechar(_tbuf *bp,unsigned int ix,int undo){
+//テキストバッファbpの先頭からixバイトの位置の1バイト削除
+//undo -1:通常BackSpace（アンドゥバッファに格納する）
+//      0:通常DELETE（アンドゥバッファに格納する）、1:連続中、2:アンドゥ中
+	unsigned char *p;
+
+	if(ix > bp->n) return; //不正指定
+	if(ix !=bp->n){
+		//バッファの最後の文字より後ろでない場合
+
+		//アンドゥバッファ設定
+		if(undo==1) pushundomem(bp->Buf[ix]); //連続削除中
+		else if(undo==-1) setundobuf(UNDO_BACKSPACE,bp,ix,bp->Buf[ix],0); //1文字削除(backspace)
+		else if(undo==0) setundobuf(UNDO_DELETE,bp,ix,bp->Buf[ix],0); //1文字削除
+
+		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,undo); //次の行の先頭文字を削除
+}
+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){
+			if(bp==disptopbp) disptopbp=bp->next; //画面左上位置が空バッファ先頭の場合、次にずらす
+			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; //編集済みフラグクリア
+	undobuf_top=undobuf;
+	undobuf_used=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<twidth;x++){
+			//文字がある位置までサーチ
+			while(ix>=bp->n){
+				if(bp==bp1 && ix==ix1){
+					if(textmode!=TMODE_MONOTEXT){
+						cl=COLOR_AREASELECTTEXT;
+					}
+					else{
+						cl=COLOR_INV;
+					}
+				}
+				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){
+					if(textmode!=TMODE_MONOTEXT){
+						cl=COLOR_AREASELECTTEXT;
+					}
+					else{
+						cl=COLOR_INV;
+					}
+			}
+			if(bp==bp2 && ix==ix2) cl=COLOR_NORMALTEXT;
+			ch=bp->Buf[ix++];
+			if(ch=='\n') break;
+			*(vp+attroffset)=cl;
+			*vp++=ch;
+		}
+		//改行およびバッファ最終以降の右側表示消去
+		for(;x<twidth;x++){
+			*(vp+attroffset)=0;
+			*vp++=0;
+		}
+	}
+	//バッファ最終以降の下側表示消去
+	for(;y<EDITWIDTHY;y++){
+		for(x=0;x<twidth;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=twidth-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>=twidth-1) x=0;
+			else x++;
+			if(ix >= bp->n){
+				bp=bp->next;
+				ix=0;
+			}
+		}
+		cx=x;
+		cx2=cx;
+		cy--;
+		line_no--;
+		return;
+	}
+
+	//左端かつ上端の場合
+	if(cursorbp->Buf[cursorix]!='\n'){
+		// 移動先が改行コードでない場合、カーソルは右端に移動
+		// 画面左上位置は画面横幅分前に移動
+		cx=twidth-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 % twidth;
+		cx2=cx;
+		line_no--;
+	}
+	//画面左上位置は現在位置から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<twidth-1){
+		//カーソル位置が改行でも右端でもない場合単純に1つ右に移動して終了
+		cx++;
+		cx2=cx;
+		return;
+	}
+	cx=0; //カーソルを左端に移動
+	cx2=cx;
+	if(c=='\n') line_no++;
+	if(cy<EDITWIDTHY-1){
+		//下端でなければカーソルを次行に移動して終了
+		cy++;
+		return;
+	}
+	//下端の場合
+	//画面左上位置を更新
+	//改行コードまたは画面横幅超えるまでサーチ
+	bp=disptopbp;
+	ix=disptopix;
+	x=0;
+	while(x<twidth){
+		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<twidth){
+		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==twidth){
+		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;
+	}
+	//改行が見つかった場合
+	//行頭（改行の次の文字またはバッファ先頭）と現在位置の文字数差を
+	//画面横幅で割った余りを求める
+	line_no--;
+	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 % twidth; //改行ブロックの最終行の右端
+	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<twidth){
+		if(ix>=bp->n){
+			if(bp->next==NULL) return; //バッファ最後までサーチしたら移動なし
+			bp=bp->next;
+			ix=0;
+			continue;
+		}
+		c=bp->Buf[ix];
+		ix++;
+		x++;
+		if(c=='\n'){
+			line_no++;
+			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<twidth){
+		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<twidth-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;
+	line_no=1;
+}
+
+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_len(_tbuf *bp,unsigned int ix,int n,int undo){
+//テキストバッファの指定位置から複数文字削除
+//bp,ix:削除開始位置
+//n:削除する文字数
+//undo:0:通常、2:アンドゥ中
+	unsigned char *p;
+	int i;
+
+	//選択範囲が最初のバッファの最後まである場合
+	if(n>=(bp->n - ix)){
+		if(!undo){
+			p=bp->Buf+ix;
+			for(i=ix;i < bp->n;i++) pushundomem(*p++); //アンドゥバッファに格納
+		}
+		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){
+		if(!undo){
+			p=bp->Buf;
+			for(i=0;i < bp->n;i++) pushundomem(*p++); //アンドゥバッファに格納
+		}
+		n-=bp->n; //削除文字数減
+		num-=bp->n; //バッファ使用量を減数
+		bp=deleteTBuf(bp); //バッファ削除して次のバッファに進む
+		if(bp==NULL) return;
+	}
+	//選択範囲の終了位置を含む場合、1文字ずつ削除
+	if(!undo) undo=1;
+	while(n>0){
+		deletechar(bp,ix,undo); //バッファから1文字削除（numは関数内で1減される）
+		n--;
+	}
+}
+void deletearea(void){
+//テキストバッファの指定範囲を削除
+//範囲は(cursorbp,cursorix)と(cursorbp1,cursorix1)で指定
+//後ろ側の一つ前の文字までを削除
+//削除後のカーソル位置は選択範囲の先頭にし、範囲選択モード解除する
+
+	_tbuf *bp;
+	int ix;
+	int n;
+
+	n=countarea(); //選択範囲の文字数カウント
+	if(n==0) return;
+
+	//範囲選択の開始位置と終了位置の前後を判断してカーソルを開始位置に設定
+	if(cy>cy1 || (cy==cy1 && cx>cx1)){
+		cursorbp=cursorbp1;
+		cursorix=cursorix1;
+		cx=cx1;
+		cy=cy1;
+		line_no=line_no1;
+	}
+	cx2=cx;
+	cursorbp1=NULL; //範囲選択モード解除
+
+	//bp,ixを開始位置に設定
+	bp=cursorbp;
+	ix=cursorix;
+
+	setundobuf(UNDO_CONTDEL,bp,ix,0,n); //アンドゥバッファ設定（連続削除開始）
+	deletearea_len(bp,ix,n,0); //n文字分削除
+	//アンドゥバッファに連続削除終了設定
+	pushundomem2(bpixtopos(bp,ix));
+	pushundomem2(n);
+	pushundomem(UNDO_CONTDEL);
+}
+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;
+
+	if(clipsize==0 || num+clipsize>TBUFMAXSIZE) return;
+	setundobuf(UNDO_CONTINS,cursorbp,cursorix,0,clipsize); //アンドゥバッファ設定
+	p=clipboard;
+	for(n=clipsize;n>0;n--){
+		i=insertchar(cursorbp,cursorix,*p,1);
+		if(i>0){
+			//バッファ空きがあるのに挿入失敗の場合
+			gabagecollect2(); //全体ガベージコレクション
+			i=insertchar(cursorbp,cursorix,*p,1);//テキストバッファに１文字挿入
+		}
+		if(i!=0) break;//挿入失敗
+		cursor_right();//画面上、バッファ上のカーソル位置を1つ後ろに移動
+		p++;
+	}
+}
+void movecursor(int pos){
+// カーソルを現在の位置から任意の位置に移動
+// pos：移動したいテキストバッファ先頭からのバイト位置
+	int pos2,d;
+	pos2=bpixtopos(cursorbp,cursorix);
+	d=pos-pos2;
+	if(d==0) return;
+	if(d>0){
+		while(d>0){
+			cursor_right();
+			d--;
+		}
+	}
+	else{
+		while(d<0){
+			cursor_left();
+			d++;
+		}
+	}
+}
+void undoexec(){
+//アンドゥ実行
+	unsigned char c,c1;
+	_tbuf *bp;
+	unsigned short n,ix;
+	int pos;
+
+	if(undobuf_used==0) return; //アンドゥバッファ空
+	cursorbp1=NULL; //範囲選択解除
+	c=popundomem(); //アンドゥバッファ先頭の命令読み出し
+	switch(c){
+		case UNDO_INSERT: //1文字挿入
+			//カーソル移動し1文字削除
+			pos=popundomem2();
+			movecursor(pos);
+			bp=postobpix(pos,&ix);
+			deletechar(bp,ix,2);
+			popundomem(); //dummy read
+			break;
+		case UNDO_CONTINS: //連続挿入
+			//カーソル移動し連続数分削除
+			n=popundomem2();
+			pos=popundomem2();
+			movecursor(pos);
+			bp=postobpix(pos,&ix);
+			deletearea_len(bp,ix,n,2);
+			popundomem(); //dummy read
+			break;
+		case UNDO_CONTDEL: //連続削除
+			//カーソル移動し連続数分、コードを読み出して挿入
+			n=popundomem2();
+			pos=popundomem2();
+			movecursor(pos);
+			bp=postobpix(pos,&ix);
+			while(n>0){
+				insertchar(bp,ix,popundomem(),2);
+				n--;
+			}
+			popundomem2(); //dummy read
+			popundomem(); //dummy read
+			break;
+		case 0: //0の場合、次の1バイトが実際の有効なコード
+			c=popundomem();
+		default: //1文字削除（DEL、BS）、1文字上書き
+			//カーソル移動し1文字挿入（または上書き）
+			pos=popundomem2();
+			movecursor(pos);
+			bp=postobpix(pos,&ix);
+			c1=popundomem();
+			if(c1==UNDO_OVERWRITE){
+				overwritechar(bp,ix,c,2);
+			}
+			else{
+				insertchar(bp,ix,c,2);
+				if(c1==UNDO_BACKSPACE) cursor_right();
+			}
+			break;
+	}
+}
+
+void set_areamode(){
+//範囲選択モード開始時のカーソル開始位置グローバル変数設定
+	cursorbp1=cursorbp;
+	cursorix1=cursorix;
+	cx1=cx;
+	cy1=cy;
+	line_no1=line_no;
+}
+void save_cursor(void){
+//カーソル関連グローバル変数を一時避難
+	cursorbp_t=cursorbp;
+	cursorix_t=cursorix;
+	disptopbp_t=disptopbp;
+	disptopix_t=disptopix;
+	cx_t=cx;
+	cy_t=cy;
+	line_no_t=line_no;
+}
+void restore_cursor(void){
+//カーソル関連グローバル変数を一時避難場所から戻す
+	cursorbp=cursorbp_t;
+	cursorix=cursorix_t;
+	disptopbp=disptopbp_t;
+	disptopix=disptopix_t;
+	cx=cx_t;
+	cy=cy_t;
+	line_no=line_no_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();
+		cursor_top();
+	}
+	return er;
+}
+int overwritecheck(char *fn){
+// ファイルの上書き確認
+// ファイルの存在をチェックし、存在する場合キーボードから上書き確認する
+// fn:ファイル名へのポインタ
+// 戻り値　0：存在しないまたは上書き、-1：上書きしない
+	SearchRec sr;
+	unsigned short vk;
+	if(FindFirst(fn,ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_ARCHIVE,&sr)) return 0; //ファイルが存在しない
+	setcursorcolor(COLOR_ERRORTEXT);
+	printstr(fn);
+	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 printfilename(unsigned char x,unsigned char y,int f,int num_dir){
+// x,yの位置にファイル名またはディレクトリ名を表示
+
+	if(f==-2){
+		setcursor(x,y,COLOR_ERRORTEXT);
+		printchar('<');
+		printstr("New FILE");
+		printchar('>');
+	}
+	else if(f==-1){
+		setcursor(x,y,COLOR_ERRORTEXT);
+		printchar('<');
+		printstr("New Dir");
+		printchar('>');
+	}
+	else if(f<num_dir){
+		setcursor(x,y,COLOR_DIR);
+		printchar('[');
+		printstr(filenames[f]);
+		printchar(']');
+	}
+	else{
+		setcursor(x,y,COLOR_NORMALTEXT);
+		printstr(filenames[f]);
+	}
+}
+int select_dir_file(int filenum,int num_dir, unsigned char* msg){
+// filenames[]配列に読み込まれたファイルまたはディレクトリを画面表示しキーボードで選択する
+// filenum:ファイル＋ディレクトリ数
+// num_dir:ディレクトリ数（filenames[]は先頭からnum_dir-1までがディレクトリ）
+// msg:画面上部に表示するメッセージ
+// 戻り値
+//　filenames[]の選択されたファイルまたはディレクトリ番号
+//　-1：新規ディレクトリ作成、tempfile[]にディレクトリ名
+//　-2：新規ファイル作成、tempfile[]にファイル名
+//　-3：ESCキーが押された
+	int top,f;
+	unsigned char *ps,*pd;
+	int x,y;
+	unsigned char vk;
+	unsigned char vm;
+
+	//ファイル一覧を画面に表示
+	vm=videomode;
+	set_videomode(VMODE_STDTEXT,0);
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	printstr(msg);
+	printstr(": ");
+	setcursorcolor(4);
+	printstr("Select&[Enter] / [ESC]\n");
+	for(f=-2;f<filenum;f++){
+		x=(f&1)*15+1;
+		y=(f+2)/2+1;
+		if(y>=twidthy-1) break;
+		printfilename(x,y,f,num_dir);
+	}
+	top=-2;//画面一番先頭のファイル番号
+	f=-2;//現在選択中のファイル番号
+	while(1){
+		setcursor((f&1)*15,(f-top)/2+1,5);
+		printchar(0x1c);// Right Arrow
+		cursor--;
+		while(1){
+			inputchar();
+			vk=vkey & 0xff;
+			if(vk) break;
+		}
+		printchar(' ');
+		setcursor(0,twidthy-1,COLOR_NORMALTEXT);
+		for(x=0;x<twidth-1;x++) printchar(' '); //最下行のステータス表示を消去
+		switch(vk){
+			case VK_UP:
+			case VK_NUMPAD8:
+				//上矢印キー
+				if(f>=0){
+					f-=2;
+					if(f<top){
+						//画面最上部の場合、下にスクロールして最上部にファイル名2つ表示
+						setcursor(twidth-1,twidthy-2,COLOR_NORMALTEXT);
+						while(cursor>=TVRAM+twidth*2){
+							*cursor=*(cursor-twidth);
+							*(cursor+attroffset)=*(cursor+attroffset-twidth);
+							cursor--;
+						}
+						while(cursor>=TVRAM+twidth) *cursor--=' ';
+						top-=2;
+						printfilename(1,1,top,num_dir);
+						printfilename(16,1,top+1,num_dir);
+					}
+				}
+				break;
+			case VK_DOWN:
+			case VK_NUMPAD2:
+				//下矢印キー
+				if(((f+2)&0xfffe)<filenum){
+					f+=2;
+					if(f>=filenum) f--;
+					if(f-top>=(twidthy-2)*2){
+						//画面最下部の場合、上にスクロールして最下部にファイル名1つor2つ表示
+						setcursor(0,1,COLOR_NORMALTEXT);
+						while(cursor<TVRAM+twidth*(twidthy-2)){
+							*cursor=*(cursor+twidth);
+							*(cursor+attroffset)=*(cursor+attroffset+twidth);
+							cursor++;
+						}
+						while(cursor<TVRAM+twidth*(twidthy-1)) *cursor++=' ';
+						top+=2;
+						printfilename(1,twidthy-2,f&0xfffe,num_dir);
+						if((f|1)<filenum){
+							printfilename(16,twidthy-2,f|1,num_dir);
+						}
+					}
+				}
+				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
+				if(f==-2){
+					//新規ファイル
+					setcursor(0,twidthy-1,COLOR_ERRORTEXT);
+					printstr("Input File Name: ");
+					setcursorcolor(COLOR_NORMALTEXT);
+					//ファイル名入力
+					*tempfile=0;
+					if(lineinput(tempfile,8+1+3)<0) break; //ESCキー
+					if(*tempfile==0) break; //ファイル名入力なし
+				}
+				else if(f==-1){
+					//新規ディレクトリ
+					setcursor(0,twidthy-1,COLOR_ERRORTEXT);
+					printstr("Input Dir Name: ");
+					setcursorcolor(COLOR_NORMALTEXT);
+					//ディレクトリ名入力
+					*tempfile=0;
+					if(lineinput(tempfile,8+1+3)<0) break; //ESCキー
+					if(FSmkdir(tempfile)){
+						setcursor(0,twidthy-1,COLOR_ERRORTEXT);
+						printstr("Cannot Make Directory        ");
+						break;
+					}
+				}
+				else{
+					//ファイル名またはディレクトリ名をtempfileにコピー
+					ps=filenames[f];
+					pd=tempfile;
+					while(*ps) *pd++=*ps++;
+					*pd=0;
+				}
+				set_videomode(vm,0);
+				return f;
+			case VK_ESCAPE:
+				//ESCキー
+				set_videomode(vm,0);
+				return -3;
+		}
+	}
+}
+int getfilelist(int *p_num_dir){
+// カレントディレクトリでのディレクトリ、.BAS、.TXT、.INIファイル一覧を読み込む
+// *p_num_dir:ディレクトリ数を返す
+// filenames[]:ファイル名およびディレクトリ名一覧
+// 戻り値　ファイル＋ディレクトリ数
+
+	unsigned char *ps,*pd;
+	int filenum;
+	SearchRec sr;
+	filenum=0;
+	//ディレクトリのサーチ
+	if(FindFirst("*.*",ATTR_DIRECTORY,&sr)==0){
+		do{
+			//filenames[]にディレクトリ名の一覧を読み込み
+			ps=sr.filename;
+			pd=filenames[filenum];
+			while(*ps!=0) *pd++=*ps++;
+			*pd=0;
+			filenum++;
+		}
+		while(!FindNext(&sr) && filenum<MAXFILENUM);
+	}
+	*p_num_dir=filenum;
+	if(filenum>=MAXFILENUM) return filenum;
+	//拡張子 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) return filenum;
+	//拡張子 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) return filenum;
+	//拡張子 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);
+	}
+	return filenum;
+}
+void save_as(int ow){
+// 現在のテキストバッファの内容をSDカードに保存
+// ow　0:名前を付けて保存　　1:上書き保存
+// ファイル名はグローバル変数currentfile[]
+// ファイル名はキーボードから変更可能
+// 成功した場合currentfileを更新
+
+	int er;
+	int filenum,num_dir,f;
+	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;
+
+	//カレントディレクトリを変数cwdpathにコピー
+	while(1){
+		if(FSgetcwd(cwdpath,PATHNAMEMAX)) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Get Current Dir\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+	//現在のディレクトリのパスを表示
+	setcursorcolor(COLOR_NORMALTEXT);
+	printstr("Current Directory is\n");
+	printstr(cwdpath);
+	printchar('\n');
+	while(1){
+		if(ow==0){
+			printstr("Input File Name + [Enter]\n");
+			printstr("[ESC] Select File/Dir or Quit\n");
+			//ファイル名入力
+			if(lineinput(tempfile,8+1+3)<0){
+				//ESCキーが押された場合、ファイル選択、ディレクトリ変更画面または終了
+				while(1){
+					filenum=getfilelist(&num_dir); //ディレクトリ、ファイル名一覧を読み込み
+					f=select_dir_file(filenum,num_dir,"Save"); //ファイルの選択
+					cls();
+					if(f==-3){
+						//終了
+						FSchdir(cwdpath);//カレントディレクトリを元に戻す
+						return;
+					}
+					else if(f==-2){
+						//新規ファイル
+						if(overwritecheck(tempfile)==0) break;//上書きチェック
+					}
+					else if(f<num_dir){
+						//新規ディレクトリまたはディレクトリ変更
+						FSchdir(tempfile);//ディレクトリ変更して再度ファイル一覧へ
+					}
+					else break;
+				}
+			}
+			else{
+				if(*tempfile==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;
+			FSgetcwd(cwdpath,PATHNAMEMAX); //カレントパスを更新
+			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 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 msra(void){
+// Make Self-Running Application （自己実行アプリケーションの作成）
+// 最初にソースファイルを名前を付けて保存
+// 次にBASICシステムのHEXファイルをソースファイル名の拡張子をHEXにした名前でコピー
+
+	int er;
+	unsigned char *ps,*pd;
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	printstr("Make Self-Running Application\n\n");
+	printstr("(Work on Root Directory)\n");
+
+	//カレントディレクトリを変数cwdpathにコピー
+	while(1){
+		if(FSgetcwd(cwdpath,PATHNAMEMAX)) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Get Current Dir\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+	while(1){
+		//カレントディレクトリをルートに変更
+		if(FSchdir((char *)ROOTDIR)==0) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Change To Root Dir\n");
+		if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+	//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){
+			//ESCキーが押された
+			FSchdir(cwdpath); //カレントディレクトリを元に戻す
+			return;
+		}
+		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");
+
+		//ファイルシステム再初期化、あきらめた場合はreturnする
+		if(filesystemretry()){
+			if(FSchdir(cwdpath)){
+				cwdpath[0]='\\';
+				cwdpath[1]=0;
+			}
+			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(FSchdir(cwdpath)){
+		cwdpath[0]='\\';
+		cwdpath[1]=0;
+	}
+	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 fileload(void){
+// SDカードからファイルを選択して読み込み
+// currenfile[]にファイル名を記憶
+// 対象ファイル拡張子 BASおよびTXT
+// 戻り値　0：読み込みを行った　-1：読み込みなし
+	int filenum,f,er;
+	unsigned char *ps,*pd;
+	unsigned char vk;
+	int num_dir;//ディレクトリ数
+
+	//ファイルの一覧を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;
+		}
+	}
+	//カレントディレクトリを変数cwdpathにコピー
+	while(1){
+		if(FSgetcwd(cwdpath,PATHNAMEMAX)) break;
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Cannot Get Current Dir\n");
+		if(filesystemretry()) return -1; //ファイルシステム再初期化、あきらめた場合はreturnする
+	}
+	while(1){
+		filenum=getfilelist(&num_dir); //ディレクトリ、ファイル名一覧を読み込み
+		if(filenum==0){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr(".BAS or .TXT File Not Found\n");
+			printstr((unsigned char *)Message1);// Hit Any Key
+			inputchar(); //1文字入力待ち
+			FSchdir(cwdpath);//カレントディレクトリを元に戻す
+			return -1;
+		}
+		//ファイルの選択
+		f=select_dir_file(filenum,num_dir,"Load");
+		if(f==-3){
+			//読み込まずに終了
+			FSchdir(cwdpath);//カレントディレクトリを元に戻す
+			return -1;
+		}
+		else if(f==-2){
+			//新規ファイルまたはファイル名を入力して読み込み
+			er=loadtextfile(tempfile); //テキストバッファにファイル読み込み
+			if(er==ERR_CANTFILEOPEN){
+				//ファイルが存在しない場合、新規テキスト
+				edited=0;
+				newtext();
+			}
+			else if(er==ERR_FILETOOBIG){
+				//ファイルサイズエラーの場合、選択画面に戻る
+				setcursor(0,twidthy-1,COLOR_ERRORTEXT);
+				printstr("File Too Big                 ");
+				wait60thsec(60);//1秒待ち
+				continue;
+			}
+			//currenfile[]にファイル名をコピー
+			ps=tempfile;
+			pd=currentfile;
+			while(*ps) *pd++=*ps++;
+			*pd=0;
+			FSgetcwd(cwdpath,PATHNAMEMAX);//cwdpathをカレントディレクトリのパスに変更
+			return 0;
+		}
+		else if(f<num_dir){
+			//新規ディレクトリまたはディレクトリ変更して、再度ファイル一覧画面へ
+			FSchdir(tempfile);
+		}
+		else{
+			er=loadtextfile(filenames[f]); //テキストバッファにファイル読み込み
+			if(er==0){
+				//cwdpath[]、currenfile[]にパス、ファイル名をコピーして終了
+				FSgetcwd(cwdpath,PATHNAMEMAX);
+				ps=filenames[f];
+				pd=currentfile;
+				while(*ps!=0) *pd++=*ps++;
+				*pd=0;
+				return 0;
+			}
+			setcursor(0,twidthy-1,COLOR_ERRORTEXT);
+			if(er==ERR_CANTFILEOPEN) printstr("Cannot Open File             ");
+			else if(er=ERR_FILETOOBIG) printstr("File Too Big                 ");
+			wait60thsec(60);//1秒待ち
+		}
+	}
+}
+void changewidth(void){
+// 画面幅の切り替え
+	if(videomode==VMODE_STDTEXT) set_videomode(VMODE_WIDETEXT,0);
+	else if(videomode==VMODE_WIDETEXT) set_videomode(VMODE_MONOTEXT,0);
+	else set_videomode(VMODE_STDTEXT,0);
+	cursor_top(); //カーソルをテキストバッファの先頭に設定
+	redraw(); //再描画
+}
+void run(int test){
+//KM-BASICコンパイル＆実行
+// test 0:コンパイルと実行、0以外:コンパイルのみで終了
+	int er,er2;
+	FSFILE *fp;
+	unsigned int disptoppos,cursorpos;
+	unsigned char widthmode;
+	int i,edited1;
+	_tbuf *bp;
+	unsigned short ix;
+	unsigned char *p;
+
+	cls();
+	setcursor(0,0,COLOR_NORMALTEXT);
+	while(1){
+		//カレントディレクトリをルートに変更
+		if(FSchdir((char *)ROOTDIR)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Change To Root Dir\n");
+			if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+			continue;
+		}
+		//ルートディレクトリのパス名保存ファイルに実行時パスを保存
+		fp=FSfopen(WORKDIRFILE,"w");
+		if(fp==NULL){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Open Work Dir File\n");
+			if(filesystemretry()){
+				//ファイルシステム再初期化、あきらめた場合はカレントディレクトリを戻しreturnする
+				FSchdir(cwdpath);
+				return;
+			}
+			continue;
+		}
+		for(p=cwdpath;*p;p++) ;
+		er=FSfwrite(cwdpath,1,p-cwdpath+1,fp);
+		FSfclose(fp);
+		if(er!=p-cwdpath+1){
+			FSremove(WORKDIRFILE);
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Write Work Dir File\n");
+			if(filesystemretry()){
+				//ファイルシステム再初期化、あきらめた場合はカレントディレクトリを戻しreturnする
+				FSchdir(cwdpath);
+				return;
+			}
+			continue;
+		}
+		break;
+	}
+	while(1){
+		//カレントディレクトリを元に戻す
+		if(FSchdir(cwdpath)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Change To CWD\n");
+			if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+			continue;
+		}
+		//実行用引渡しファイルに保存
+		if(savetextfile(TEMPFILENAME)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Write To SD Card\n");
+			if(filesystemretry()) return; //ファイルシステム再初期化、あきらめた場合はreturnする
+			continue;
+		}
+		break;
+	}
+
+	//カーソル位置、画面表示位置、画面モードの保存
+	disptoppos=bpixtopos(disptopbp,disptopix);
+	cursorpos=bpixtopos(cursorbp,cursorix);
+	widthmode=videomode;
+	edited1=edited; //編集済みフラグの一時退避
+	set_videomode(VMODE_T30,0);//30文字モードに設定
+
+	// 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);
+	inputchar(); //1文字入力待ち
+	stop_music(); //音楽再生停止
+	init_composite(); //パレット初期化のため画面初期化
+
+	//画面モードを戻す
+	set_videomode(widthmode,0);
+
+	FSgetcwd(cwdpath,PATHNAMEMAX);//カレントディレクトリパス変数を戻す
+	while(1){
+		//カレントディレクトリをルートに変更
+		if(FSchdir((char *)ROOTDIR)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Change To Root Dir\n");
+			filesystemretry(); //ファイルシステム再初期化
+			continue;
+		}
+		//ルートディレクトリのパス名保存ファイルからパス名を読み出し
+		fp=FSfopen(WORKDIRFILE,"r");
+		if(fp==NULL){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Open Work Dir File\n");
+			filesystemretry(); //ファイルシステム再初期化
+			continue;
+		}
+		er=FSfread(cwdpath,1,PATHNAMEMAX,fp);
+		FSfclose(fp);
+		if(er<=0){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Read Work Dir File\n");
+			filesystemretry(); //ファイルシステム再初期化
+			continue;
+		}
+		FSremove(WORKDIRFILE); //パス名保存ファイル削除
+		break;
+	}
+	while(1){
+		//カレントディレクトリを元に戻す
+		if(FSchdir(cwdpath)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Change To CWD\n");
+			filesystemretry(); //ファイルシステム再初期化
+			continue;
+		}
+		//実行用引渡しファイルから元に戻す
+		if(loadtextfile(TEMPFILENAME)){
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Cannot Load From SD Card\n");
+			filesystemretry(); //ファイルシステム再初期化
+			continue;
+		}
+		break;
+	}
+	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;
+		line_no=er2;
+		//中央になるようスクロール
+		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;
+	int t;
+	p=cursor; //カーソル位置の退避
+	c=cursorcolor;
+	if(shiftkeys() & CHK_SHIFT){
+		if(videomode!=VMODE_MONOTEXT){
+			setcursor(0,twidthy-1,COLOR_BOTTOMLINE);
+			printstr("NEW  |MSRA |WIDTH|TEST | ");
+		}
+		else{
+			setcursor(0,twidthy-1,COLOR_INV);
+			printstr(" NEW  \x87 MSRA \x87 WIDTH\x87 TEST \x87\x87");
+		}
+		setcursorcolor(COLOR_ERRORTEXT);
+		t=TBUFMAXSIZE-num;
+		if(t==0) t=1;
+		while(t<10000){
+			printchar(' ');
+			t*=10;
+		}
+		printstr("LEFT:");
+		printnum(TBUFMAXSIZE-num);
+	}
+	else{
+		if(videomode!=VMODE_MONOTEXT){
+			setcursor(0,twidthy-1,COLOR_BOTTOMLINE);
+			printstr("LOAD |SAVE |     |RUN  | ");
+		}
+		else{
+			setcursor(0,twidthy-1,COLOR_INV);
+			printstr(" LOAD \x87 SAVE \x87      \x87 RUN  \x87\x87");
+		}
+		setcursorcolor(COLOR_ERRORTEXT);
+		t=line_no;
+		if(t==0) t=1;
+		while(t<10000){
+			printchar(' ');
+			t*=10;
+		}
+		printstr("LINE:");
+		printnum(line_no);
+	}
+	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,0);//テキストバッファに１文字挿入
+		if(i>0){
+			//バッファ空きがあるのに挿入失敗の場合
+			gabagecollect2(); //全体ガベージコレクション
+			i=insertchar(cursorbp,cursorix,k,0);//テキストバッファに１文字挿入
+		}
+		if(i==0) cursor_right();//画面上、バッファ上のカーソル位置を1つ後ろに移動
+	}
+	else{ //上書きモード
+		i=overwritechar(cursorbp,cursorix,k,0);//テキストバッファに１文字上書き
+		if(i>0){
+			//バッファ空きがあるのに上書き（挿入）失敗の場合
+			//（行末やバッファ最後尾では挿入）
+			gabagecollect2(); //全体ガベージコレクション
+			i=overwritechar(cursorbp,cursorix,k,0);//テキストバッファに１文字上書き
+		}
+		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,0);
+			break;
+		case VK_BACK: //BackSpaceキー
+			edited=1; //編集済みフラグ
+			if(cursorbp1!=NULL){
+				deletearea();//選択範囲を削除
+				break;
+			}
+			if(cursorix==0 && cursorbp->prev==NULL) break; //バッファ先頭では無視
+			cursor_left();
+			deletechar(cursorbp,cursorix,-1);
+			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(fileload()==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(fileload()==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_F3: //F3キー
+			if(sh & CHK_SHIFT) changewidth(); //画面幅の切り替え
+			break;
+		case VK_F4: //F4キー
+			if(num==0) break;
+			if(sh & CHK_SHIFT) run(1); //コンパイルテスト
+			else run(0); //コンパイル＆実行
+			break;
+		case 'Z':
+			//CTRL+Z、アンドゥ
+			if(sh & CHK_CTRL) undoexec();
+			break;
+	}
+}
+void texteditor(void){
+//テキストエディター本体
+	unsigned char k1,k2,sh;
+	FSFILE *fp;
+
+	editormallocp=RAM;
+	TextBuffer=(_tbuf *)editormalloc(sizeof(_tbuf)*TBUFMAXLINE);
+	clipboard=editormalloc(WIDTH_XMAX*EDITWIDTHY);
+	filebuf=editormalloc(FILEBUFSIZE);
+	cwdpath=editormalloc(PATHNAMEMAX);
+	filenames=(unsigned char (*)[])editormalloc(MAXFILENUM*13);
+	undobuf=editormalloc(UNDOBUFSIZE);
+
+//	TextBuffer=(_tbuf *)RAM;
+//	clipboard=(unsigned char *)TextBuffer+sizeof(_tbuf)*TBUFMAXLINE;
+//	filebuf=clipboard+WIDTH_XMAX*EDITWIDTHY;
+//	cwdpath=filebuf+FILEBUFSIZE;
+//	filenames=(unsigned char (*)[])(cwdpath+PATHNAMEMAX);
+//	undobuf=(unsigned char *)filenames+MAXFILENUM*13;
+
+	inittextbuf(); //テキストバッファ初期化
+	currentfile[0]=0; //作業中ファイル名クリア
+	cwdpath[0]='\\'; //カレントディレクトリをルートに設定
+	cwdpath[1]=0;
+
+	//実行時生成一時ファイルがあった場合は読み込む
+	fp=FSfopen(WORKDIRFILE,"r");
+	if(fp!=NULL){
+		FSfread(cwdpath,1,PATHNAMEMAX,fp);
+		FSfclose(fp);
+		FSchdir(cwdpath);
+		if(loadtextfile(TEMPFILENAME)==0){
+			edited=1;
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Temporary File Loaded\n");
+			printstr("Current Directory is\n");
+			setcursorcolor(COLOR_DIR);
+			printstr(cwdpath);
+			setcursorcolor(COLOR_ERRORTEXT);
+			printstr("\nSave To SD Card If Necessary\n");
+			setcursorcolor(COLOR_NORMALTEXT);
+			printstr((unsigned char *)Message1); //Hit Any Key
+			inputchar(); //1文字入力待ち
+		}
+		else{
+			cwdpath[0]='\\'; //カレントディレクトリをルートに設定
+			cwdpath[1]=0;
+		}
+	}
+	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/trunk/megalopa/envspecific.h	(nonexistent)
+++ mips/trunk/megalopa/envspecific.h	(revision 268)
@@ -0,0 +1,90 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+// Megalopa uses I/O statements/functions
+#include "io.h"
+
+#define PERSISTENT_RAM_SIZE (1024*100)
+
+int readbuttons();
+void scroll(int x, int y);
+void usegraphic(int mode);
+void videowidth(int width);
+int lib_system(int a0, int a1 ,int v0, int a3, int g_gcolor, int g_prev_x, int g_prev_y);
+void init_env(void);
+void pre_run(void);
+void post_run(void);
+
+// 30 or 40 characters per line for Zoea
+#define printcomma() printstr("          "+rem10_32((unsigned int)(cursor-TVRAM)))
+
+// 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 (ps2keystatus[0x03]) err_break();\
+	}
+
+// Megalopa specific lists of statements and functions
+#define ADDITIONAL_STATEMENTS \
+	"OUT "      ,out_statement,\
+	"OUT8H "    ,out8h_statement,\
+	"OUT8L "    ,out8l_statement,\
+	"OUT16 "    ,out16_statement,\
+	"PWM "      ,pwm_statement,\
+	"SERIAL "   ,serial_statement,\
+	"SERIALOUT ",serialout_statement,
+
+#define ADDITIONAL_INT_FUNCTIONS \
+	"IN("  ,    in_function,\
+	"IN8H("  ,  in8h_function,\
+	"IN8L("  ,  in8l_function,\
+	"IN16("  ,  in16_function,\
+	"ANALOG("  ,analog_function,\
+	"SERIALIN(",serialin_function,
+
+#define ADDITIONAL_STR_FUNCTIONS
+#define ADDITIONAL_RESERVED_VAR_NAMES \
+	0x00015045, /*OUT*/ \
+	0x01975e81, /*OUT8H*/ \
+	0x01975e85, /*OUT8L*/ \
+	0x01975d7a, /*OUT16*/ \
+	0x0001015b, /*IN*/ \
+	0x0007dde1, /*IN8H*/ \
+	0x0007dde5, /*IN8L*/ \
+	0x0007dcda, /*IN16*/ \
+	0x05f0a740, /*ANALOG*/ \
+	0x00015596, /*PWM*/ \
+	0x45f58f5d, /*SERIAL*/ \
+	0x000163c6, /*SPI*/ \
+	0x47093355, /*SPIOUT*/ \
+	0x01fa1cff, /*SPIIN*/
+
+
+#define EXTRA_MASK 0x003F
+#define EXTRA_STEP 0x0001
+enum extra{
+	EXTRA_SYSTEM     =EXTRA_STEP*0,
+	EXTRA_OUT        =EXTRA_STEP*1,
+	EXTRA_OUT8H      =EXTRA_STEP*2,
+	EXTRA_OUT8L      =EXTRA_STEP*3,
+	EXTRA_OUT16      =EXTRA_STEP*4,
+	EXTRA_IN         =EXTRA_STEP*5,
+	EXTRA_IN8H       =EXTRA_STEP*6,
+	EXTRA_IN8L       =EXTRA_STEP*7,
+	EXTRA_IN16       =EXTRA_STEP*8,
+	EXTRA_ANALOG     =EXTRA_STEP*9,
+	EXTRA_PWM        =EXTRA_STEP*10,
+	EXTRA_SERIALOUT  =EXTRA_STEP*11,
+	EXTRA_SERIALIN   =EXTRA_STEP*12,
+	EXTRA_SERIAL     =EXTRA_STEP*13,
+	EXTRA_SPIOUT     =EXTRA_STEP*14,
+	EXTRA_SPIIN      =EXTRA_STEP*15,
+	EXTRA_SPI        =EXTRA_STEP*16,
+	// MAX 63
+};

--- mips/trunk/megalopa/run.c	(nonexistent)
+++ mips/trunk/megalopa/run.c	(revision 268)
@@ -0,0 +1,152 @@
+/*
+   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.
+	// Clear object area
+	for(i=0;i<RAMSIZE/4;i++) g_object[i]=0x00000000;
+	// 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);
+	g_long_name_var_num=0;
+	cmpdata_init();
+
+	// Initialize music system
+	init_music();
+
+	printstr("BASIC "BASVER"\n");
+	wait60thsec(15);
+
+	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=0x92D68CA2; //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();
+	// Initialize file system
+	lib_file(FUNC_FINIT,0,0,0);
+
+	// Assign memory
+	set_free_area((void*)(g_object+g_objpos),(void*)(&RAM[RAMSIZE]));
+
+	// Warm up environment
+	pre_run();
+
+	// 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");
+
+	// Cool down environment
+	post_run();
+	lib_file(FUNC_FINIT,0,0,0);
+
+	return 0;
+}

--- mips/trunk/megalopa/debug.c	(nonexistent)
+++ mips/trunk/megalopa/debug.c	(revision 268)
@@ -0,0 +1,245 @@
+/*
+   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"
+#include "compiler.h"
+
+/*
+	Enable following line when debugging binary object.
+*/
+//#include "debugdump.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;
+
+/*
+	Debug dump
+	In debugdump.h:
+		__DEBUGDUMP is defined.
+		__DEBUGDUMP_FREEAREA is defined as start address of free area (1st argument of set_free_area() function)
+		const unsigned char dump[] is initialized.
+*/
+#ifdef __DEBUGDUMP
+int debugDump(){
+	int i;
+	for(i=0;i<sizeof dump;i++){
+		RAM[i]=dump[i];
+	}
+
+	g_objpos=(__DEBUGDUMP_FREEAREA-(unsigned int)g_object)/4;
+
+	// 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);
+
+	printstr("Compiling...");
+
+	// Initialize the other parameters
+	// Random seed
+	g_rnd_seed=0x92D68CA2; //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");
+	g_use_graphic=0;
+
+	return 1;
+}
+#else
+int debugDump(){
+	return 0;
+}
+#endif
+
+/*
+    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];
+		// Try debugDump.
+		if (debugDump()) return 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;
+}
+int FSmkdir (char * path){
+	return 0;
+}
+char * FSgetcwd (char * path, int numchars){
+	return 0;
+}
+int FSchdir (char * path){
+	return 0;
+}
+long FSftell (FSFILE * fo){
+	return 0;
+}
+int FSfseek(FSFILE *stream, long offset, int whence){
+	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"
+"print NOT(0);IN(0)\n"
+"\n";
+
+/*
+    Test function for constructing assemblies from C codes.
+*/
+
+int _debug_test(int a0, int a1, int a2, int a3, int param4, int param5){
+//	if (a0<0xa0008192) return 0xa0000000;
+	asm volatile("lw $sp,18($fp)");
+	asm volatile("addiu $sp,$sp,2044");
+	return a2+a3;
+}
+
+/*
+	Break point used for debugging object code.
+
+g_object[g_objpos++]=0x0000000d;// break 0x0
+
+*/
+
+#endif // __DEBUG

--- mips/trunk/megalopa/io.h	(nonexistent)
+++ mips/trunk/megalopa/io.h	(revision 268)
@@ -0,0 +1,34 @@
+/*
+   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/
+*/
+
+void lib_out(int pos, int val);
+void lib_out8h(int val);
+void lib_out8l(int val);
+int lib_out16(int val);
+int lib_in(int pos);
+int lib_in8h();
+int lib_in8l();
+int lib_in16();
+int lib_analog(int pos);
+void lib_pwm(int duty, int freq, int num);
+void lib_serial(int baud, int parity, int bsize);
+void lib_serialout(int data);
+int lib_serialin(int mode);
+
+char* out_statement();
+char* out8h_statement();
+char* out8l_statement();
+char* out16_statement();
+char* pwm_statement();
+char* serial_statement();
+char* serialout_statement();
+char* in_function();
+char* in8h_function();
+char* in8l_function();
+char* in16_function();
+char* analog_function();
+char* serialin_function();

--- mips/trunk/megalopa/memory.c	(nonexistent)
+++ mips/trunk/megalopa/memory.c	(revision 268)
@@ -0,0 +1,184 @@
+/*
+   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;
+}
+
+int get_permanent_var_num(){
+	int i;
+	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++) {
+		if (g_var_size[i]==0) return i;
+	}
+	err_no_block();
+	return 0;
+}

--- mips/trunk/megalopa/varname.c	(nonexistent)
+++ mips/trunk/megalopa/varname.c	(revision 268)
@@ -0,0 +1,228 @@
+/*
+   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"
+
+/*
+	static const int reserved_var_names[];
+	This dimension contains var name integers of reserved var names.
+	To make following structure, execute "reservednames.js" in Windows.
+*/
+
+static const int reserved_var_names[]={
+	0x000106b8, //ABS
+	0x0001f67c, //ACOS
+	0x0002414c, //ARGS
+	0x0001090c, //ASC
+	0x0002469f, //ASIN
+	0x00024a8f, //ATAN
+	0x002f7c1e, //ATAN2
+	0x0047c31c, //BREAK
+	0x00575afe, //CDATA
+	0x00036c3d, //CEIL
+	0x000111af, //CHR
+	0x0cb1b682, //CIRCLE
+	0x005d1ea3, //CLEAR
+	0x00011240, //CLS
+	0x005f66cb, //COLOR
+	0x000112ac, //COS
+	0x0003a041, //COSH
+	0x00616415, //CREAD
+	0x0de593fb, //CURSOR
+	0x00040fbe, //DATA
+	0x00011644, //DEC
+	0x000116de, //DIM
+	0x000100a8, //DO
+	0x0004fd8e, //ELSE
+	0x1434a177, //ELSEIF
+	0x00011c99, //END
+	0x0091c927, //ENDIF
+	0x00053854, //EXEC
+	0x00011e0d, //EXP
+	0x000579c8, //FABS
+	0x16e3d4be, //FCLOSE
+	0x00058fcf, //FEOF
+	0x00059895, //FGET
+	0x00a67500, //FGETC
+	0x0005a3a2, //FILE
+	0x177f0ca5, //FINPUT
+	0x0005b1df, //FLEN
+	0x00aa3445, //FLOAT
+	0x00aa363b, //FLOOR
+	0x0005b84d, //FMOD
+	0x00ac5c9f, //FOPEN
+	0x000121db, //FOR
+	0x18352839, //FPRINT
+	0x0005c865, //FPUT
+	0x00ad2e40, //FPUTC
+	0x00aefdec, //FSEEK
+	0x00063b90, //GCLS
+	0x1a808bcb, //GCOLOR
+	0x00c60f03, //GOSUB
+	0x0006796c, //GOTO
+	0x1bcfcc39, //GPRINT
+	0x00012a99, //HEX
+	0x00010153, //IF
+	0x00f8701a, //INKEY
+	0x00f88ba5, //INPUT
+	0x000130e9, //INT
+	0x00092084, //KEYS
+	0x013be43d, //LABEL
+	0x00013ecf, //LEN
+	0x00013ed5, //LET
+	0x0009e96a, //LINE
+	0x00014030, //LOG
+	0x0145f324, //LOG10
+	0x000a07f9, //LOOP
+	0x000abca3, //MODF
+	0x016418d4, //MUSIC
+	0x000b4321, //NEXT
+	0x00014a5d, //NOT
+	0x000152c0, //PCG
+	0x000cacec, //PEEK
+	0x00010252, //PI
+	0x01ac8479, //POINT
+	0x000ce05e, //POKE
+	0x00015480, //POW
+	0x01aea739, //PRINT
+	0x000cf3d5, //PSET
+	0x3cc0fe21, //PUTBMP
+	0x000e18d5, //READ
+	0x00015d2e, //REM
+	0x425c9703, //RETURN
+	0x00015e69, //RND
+	0x45c26d49, //SCROLL
+	0x00016287, //SGN
+	0x000162cf, //SIN
+	0x000ee52d, //SINH
+	0x01f9a429, //SOUND
+	0x000f0e49, //SQRT
+	0x47f711de, //SYSTEM
+	0x000166bf, //TAN
+	0x000f72ed, //TANH
+	0x02182fee, //TVRAM
+	0x022c2a2d, //UNTIL
+	0x4e8887d0, //USEPCG
+	0x4e88a5f3, //USEVAR
+	0x000170dd, //VAL
+	0x000170e3, //VAR
+	0x00119505, //WAIT
+	0x0011a9e9, //WEND
+	0x025aef62, //WHILE
+	0x025b8d75, //WIDTH
+	// Additional names follow
+	ADDITIONAL_RESERVED_VAR_NAMES
+};
+
+/*
+	check_var_name();
+	This function reads the current position of source code and check if
+	it contains valid var name, the function returns 0 or plus value.
+	If not, it returns -1;
+*/
+
+int check_var_name(){
+	char b1;
+	int j;
+	int i=0;
+	int prevpos=g_srcpos;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1<'A' || 'Z'<b1) return -1;
+	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) {
+		// One letter var name, A-Z
+		return i-1;
+	}
+	if (6<g_srcpos-prevpos) {
+		// Too long. This is not var name.
+		g_srcpos=prevpos;
+		return -1;
+	}
+	i+=65536;
+	// Check if this is reserved var name.
+	for(j=0;j<sizeof reserved_var_names/sizeof reserved_var_names[0];j++){
+		if (reserved_var_names[j]==i) {
+			// This var name is reserved as used for function or statement.
+			g_srcpos=prevpos;
+			return -1;
+		}
+	}
+	// Reserved var names table was checked. This must be a long var name.
+	return i;
+}
+
+/*
+	int get_var_number();
+	This function returns variable number that can be used as the index of $s8
+*/
+
+int get_var_number(){
+	int i;
+	// This must be a short or long var name.
+	i=check_var_name();
+	if (i<0) return -1;
+	// If it is a short name, immediately return.
+	if (i<26) return i;
+	// Search long var names registered by USEVAR statement.
+	// If found, returns the value that can be used as the index of $s8
+	i=search_var_name(i);
+	if (i<0) return -1;
+	// This var name is defined by USEVAR statement.
+	return i+ALLOC_LNV_BLOCK;
+	
+}
+
+/*
+	int search_var_name(int nameint);
+	This function searchs registered long var name in compile data table.
+	If not found, this function returns -1.
+	If found, it retunrs var number, beginning 0.
+*/
+
+int search_var_name(int nameint){
+	int* cmpdata;
+	cmpdata_reset();
+	while(cmpdata=cmpdata_find(CMPDATA_USEVAR)){
+		if (cmpdata[1]==nameint) return cmpdata[0]&0x0000ffff;
+	}
+	return -1;
+}
+
+/*
+	char* register_var_name(int nameint);
+	This function is called when compiler detects "USEVAR" statement.
+	It registers the long file name in compile data table.
+*/
+
+char* register_var_name(int nameint){
+	// Check if registered before. If did, cause error.
+	if (search_var_name(nameint)!=-1) return ERR_INVALID_VAR_NAME;
+	// Number of long var name is restricted
+	if (ALLOC_LNV_NUM<=g_long_name_var_num) return ERR_INVALID_VAR_NAME;
+	// Register var name as a compile data
+	g_temp=nameint;
+	return cmpdata_insert(CMPDATA_USEVAR,g_long_name_var_num++,&g_temp,1);
+}

--- mips/trunk/megalopa/editor.h	(nonexistent)
+++ mips/trunk/megalopa/editor.h	(revision 268)
@@ -0,0 +1,43 @@
+/*
+   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 TBUFMAXLINE 181 //テキストバッファ数
+
+#define TBUFSIZE 200 //テキストバッファ1つのサイズ
+#define TBUFMAXSIZE (TBUFSIZE*(TBUFMAXLINE-1)) //最大バッファ容量（バッファ1行分空ける）
+//#define EDITWIDTHX 36 //エディタ画面横幅
+#define EDITWIDTHY 26 //エディタ画面縦幅
+#define COLOR_NORMALTEXT 7 //通常テキスト色
+#define COLOR_ERRORTEXT 4 //エラーメッセージテキスト色
+#define COLOR_AREASELECTTEXT 4 //範囲選択テキスト色
+#define COLOR_BOTTOMLINE 5 //画面最下行の色
+#define COLOR_DIR 6 //ディレクトリ名表示の色
+#define COLOR_INV 128 //モノクロモード時の反転
+#define FILEBUFSIZE 256 //ファイルアクセス用バッファサイズ
+#define MAXFILENUM 200 //利用可能ファイル最大数
+#define PATHNAMEMAX 128 //ワーキングディレクトリパス名の最大値
+#define UNDOBUFSIZE 2048 //アンドゥ用バッファサイズ
+
+#define ERR_FILETOOBIG -1
+#define ERR_CANTFILEOPEN -2
+#define ERR_CANTWRITEFILE -3
+
+#define TEMPFILENAME "~TEMP.BAS" //実行時ソース保存ファイル名
+#define WORKDIRFILE "~WORKDIR.TMP" //実行時パス保存ファイル名
+
+#define UNDO_INSERT 1
+#define UNDO_OVERWRITE 2
+#define UNDO_DELETE 3
+#define UNDO_BACKSPACE 4
+#define UNDO_CONTINS 5
+#define UNDO_CONTDEL 6
+
+void texteditor(void); //テキストエディタ本体
+int runbasic(char *s,int test); //コンパイルして実行
+extern unsigned char tempfile[13];
+void wait60thsec(unsigned short n);
+

--- mips/trunk/megalopa/keyinput.c	(nonexistent)
+++ mips/trunk/megalopa/keyinput.c	(revision 268)
@@ -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 "lib_video_megalopa.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/trunk/megalopa/exception.c	(nonexistent)
+++ mips/trunk/megalopa/exception.c	(revision 268)
@@ -0,0 +1,159 @@
+/*
+   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"
+
+/*
+	Enable following line if memory dump is needed when exception occurs.
+*/
+
+//#define DUMPFILE "~~MEMORY.DMP"
+
+#ifdef DUMPFILE
+void dumpMemory(){
+	unsigned int i;
+	FSFILE *fp;
+	printstr("\n"DUMPFILE" ");
+	if(FSInit()==FALSE){
+		printstr("cannot be created.\n");
+		return;
+	}
+	fp=FSfopen(DUMPFILE,"w");
+	if(fp==NULL) {
+		printstr("not saved.\n");
+		return;
+	}
+	for(i=0;i<PERSISTENT_RAM_SIZE;i+=512){
+		if (FSfwrite(&RAM[i],1,512,fp)<512) break;
+	}
+	FSfclose(fp);	
+	printstr("saved.\n");
+}
+#else
+void dumpMemory(){}
+#endif //ifdef DUMPFILE
+
+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
+		for(i=0;i<100000;i++){
+			if((readbuttons()&(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");
+
+#ifndef __DEBUG
+	dumpMemory();
+#endif
+	while(1) asm("wait");
+}

--- mips/trunk/megalopa/globalvars.c	(nonexistent)
+++ mips/trunk/megalopa/globalvars.c	(revision 268)
@@ -0,0 +1,79 @@
+/*
+   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
+unsigned 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;
+
+// Parameter-containing block used for library
+int* g_libparams;
+
+// Number of long name variables
+int g_long_name_var_num;
+
+// General purpose integer used for asigning value with pointer
+int g_temp;

--- mips/trunk/megalopa/ps2keyboard.h	(nonexistent)
+++ mips/trunk/megalopa/ps2keyboard.h	(revision 268)
@@ -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を返す）
+
+// Macros for dummy functions
+#define ps2mode() (0)
+#define buttonmode() (0)
+#define inPS2MODE() (1)

--- mips/trunk/megalopa/api.h	(nonexistent)
+++ mips/trunk/megalopa/api.h	(revision 268)
@@ -0,0 +1,42 @@
+/*
+   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 "lib_video_megalopa.h"
+#include "sdfsio370f.h"
+#include "ps2keyboard.h"
+#include "debug.h"
+
+// Palette is shared between text and graphic
+#define g_set_palette set_palette
+

--- mips/trunk/megalopa/cmpdata.c	(nonexistent)
+++ mips/trunk/megalopa/cmpdata.c	(revision 268)
@@ -0,0 +1,86 @@
+/*
+   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"
+
+/*
+	This file provide functions for handling data used when compiling.
+	The data is inserted between g_objmax and file cache.
+	Data format (32 bit):
+		MSB                LSB
+		 +----+----+--------+
+		 |type|len | data16 |
+		 +----+----+--------+
+		where,
+			type:   data type number (unsigned char)
+			len:    length of data area in number of words (unsigned char)
+			data16: general 16 bit data (short)
+*/
+
+#define g_cmpdata g_objmax
+
+static int* g_cmpdata_end;
+static int* g_cmpdata_point;
+
+/*
+	Initialize routine must be called when starting compiler.
+*/
+void cmpdata_init(){
+	g_cmpdata_end=g_objmax;
+	g_cmpdata_point=g_objmax;
+}
+
+/*
+	Function to insert a data. The data must be defined by a pointer to int array.
+		unsigned char type: Data type number (0-255)
+		short data16:       16 bit data. If not required, set 0.
+		int* data:          Pointer to data array. If not requird, set 0.
+		unsigned char num:  Length of above data array. If not required, set 0.
+*/
+char* cmpdata_insert(unsigned char type, short data16, int* data, unsigned char num){
+	unsigned char i;
+	g_cmpdata-=num+1;
+	if (g_cmpdata<g_object+g_objpos) return ERR_NE_BINARY;
+	g_cmpdata[0]=(type<<24)|(num+1)<<16|data16;
+	for(i=0;i<num;i++){
+		g_cmpdata[i+1]=data[i];
+	}
+	return 0;
+}
+
+/*
+	Reset data point. Next search will be from the beginning.
+*/
+
+void cmpdata_reset(){
+	g_cmpdata_point=g_cmpdata;
+}
+
+/*
+	Find the next record with defined type. Return the pointer to the record.
+*/
+int* cmpdata_find(unsigned char type){
+	int* ret;
+	while(g_cmpdata_point<g_cmpdata_end){
+		// Remember return value
+		ret=g_cmpdata_point;
+		// Move the point to next
+		g_cmpdata_point+=(ret[0]&0x00ff0000)>>16;
+		// Check if type is the same. If the same, return.
+		if ((ret[0]>>24)==type) return ret;
+	}
+	return 0;
+}
+
+/*
+	Find the record from beginning.
+*/
+
+int* cmpdata_findfirst(unsigned char type){
+	cmpdata_reset();
+	return cmpdata_find(type);
+}

--- mips/trunk/megalopa/float.c	(nonexistent)
+++ mips/trunk/megalopa/float.c	(revision 268)
@@ -0,0 +1,143 @@
+#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(1);
+		g_object[g_objpos++]=0x34040000;                     // ori a0,zero,0
+		call_lib_code(LIB_FLOAT | OP_SUB);
+	} 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 {
+			i=get_var_number();
+			if (i<0) {
+				// Must be a function.
+				return float_function();
+			}
+			if (g_source[g_srcpos]!='#') return ERR_SYNTAX;
+			g_srcpos++;
+			if (g_source[g_srcpos]=='(') {
+				// Dimension
+				g_srcpos++;
+				return get_dim_value(i);
+			}
+			// Simple value
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+		}
+	}
+	// 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/trunk/megalopa/string.c	(nonexistent)
+++ mips/trunk/megalopa/string.c	(revision 268)
@@ -0,0 +1,216 @@
+/*
+   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') {
+		i=get_var_number();
+		if (i<0) {
+			// 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;
+		}
+		if (g_source[g_srcpos]!='$') return ERR_SYNTAX;
+		g_srcpos++;
+		// String variable
+		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|(i);          // addiu a1,zero,xx
+			call_lib_code(LIB_MIDSTR);
+		} else {
+			// Simple string
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4);        // lw v0,xx(s8)
+			// String is pointed by $v0
+		}
+	} 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/trunk/megalopa/value.c	(nonexistent)
+++ mips/trunk/megalopa/value.c	(revision 268)
@@ -0,0 +1,267 @@
+/*
+   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(int i){
+	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|(i*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
+		// Use a stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		do {
+			g_srcpos++;
+			g_object[g_objpos++]=0xAFA20000|g_sdepth;      // sw v0,xx(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++]=0x8FA30000|g_sdepth;      // lw v1,xx(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_sdepth-=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;
+			i=get_var_number();
+			if (i<0) {
+				// Must be a function.
+				return function();
+			}
+			if (g_source[g_srcpos]=='(') {
+				// Dimension
+				g_srcpos++;
+				return get_dim_value(i);
+			}
+			// Simple value
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+		}
+	}
+	// 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 || b=='#') {
+		// 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/trunk/megalopa/compiler.c	(nonexistent)
+++ mips/trunk/megalopa/compiler.c	(revision 268)
@@ -0,0 +1,151 @@
+/*
+   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;
+	next_position();
+	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;
+	}
+}
+
+int endOfStatement(){
+	unsigned char b;
+	next_position();
+	b=g_source[g_srcpos];
+	return (b<0x20 || b==':') ? 1: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/trunk/megalopa/file.c	(nonexistent)
+++ mips/trunk/megalopa/file.c	(revision 268)
@@ -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/trunk/megalopa/keyinput.h	(nonexistent)
+++ mips/trunk/megalopa/keyinput.h	(revision 268)
@@ -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/trunk/megalopa/linker.c	(nonexistent)
+++ mips/trunk/megalopa/linker.c	(revision 268)
@@ -0,0 +1,390 @@
+/*
+   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;
+			}
+		}
+		// 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;
+			}
+		}
+		// Line number not found.
+		return 0;
+	}
+}
+
+void* search_breakout(unsigned int start, int* prevcode){
+	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;
+				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.
+				// Previous code will be also set if required for CONTINUE statement.
+				if (prevcode) prevcode[0]=g_object[pos-1];
+				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;
+				break;
+			case 0x3000: // Block marker
+				if (code1==0x30008000) {
+					// end block
+					if (0<depth) {
+						depth--;
+						break;
+					}
+					// Destination found.
+					return (void*)&g_object[pos];
+				} else if (code1==0x30000000) {
+					// begin block
+					depth++;
+					break;
+				} else {
+					break;
+				}
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+/*
+	Following codes are dedicated to specific use:
+	0x0411xxxx: String/data block
+		Use 0x0413xxxx (bzegall zero,xxxx) for other cases to get PC to $ra
+	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
+		0x08160008: CONTINUE
+		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)
+	0x3000Fxxx: General purpose NOP with value 0x0000-0x0FFF.
+
+	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;
+				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,0);
+						if (!code1) return ERR_INVALID_BREAK;
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					case 0x0008:
+						// CONTINUE statement
+						// Find next the NEXT or WHILE statement and insert jump code after this.
+						g_label=g_line;
+						code1=(int)search_breakout(pos,&g_temp);
+						if (!code1) return ERR_INVALID_BREAK;
+						if (0x3000F000 == (g_temp&0xFFFFF000)) {
+							// WEND or LOOP statement found
+							code1-=(g_temp&0x0FFF)<<2;
+						} else {
+							// NEXT statement found
+							code1-=3<<2;
+						}
+						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/trunk/megalopa/operator.c	(nonexistent)
+++ mips/trunk/megalopa/operator.c	(revision 268)
@@ -0,0 +1,273 @@
+/*
+   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;
+	// All the calculations will be done in library code, lib_float function (see below).
+	call_lib_code(LIB_FLOAT | op);
+	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/trunk/megalopa/sdfsio370f.h	(nonexistent)
+++ mips/trunk/megalopa/sdfsio370f.h	(revision 268)
@@ -0,0 +1,2357 @@
+// sdfsio370f.h
+// PIC32MX370F512HでSPI2接続されたSDカードにアクセスする
+// sdfsio370fLib.aを利用するためのヘッダーファイル
+// FSIO.h,FSconfig.h,FSDefs.hから抜粋 by K.Tanaka
+//
+// サポート
+//	FAT32,書き込み,ファイルサーチ,Dir
+// 未サポート
+//	LongFileName,FSfprintf,format,FSGetDiskProperties
+// 同時オープン数 3
+
+/******************************************************************************
+ *
+ *                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 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
+
+#define ALLOW_FILESEARCH
+#define ALLOW_WRITES
+#define ALLOW_DIRS
+#define SUPPORT_FAT32
+
+// 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 *data_to_write, 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:
+    data_to_write -     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 *data_to_write, 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