Commit: 37 - Megalopa (svn)

Commit MetaInfo

• Revision: 37 (tree)
• Zeit: 2019-03-18 00:10:49
• Autor: kenkenmkiisr

Log Message

オブジェクト指向対応

Ändern Zusammenfassung

• added: trunk/args.c
• added: trunk/class.c
• added: trunk/class.txt
• modified: trunk/cmpdata.c
• modified: trunk/compiler.c
• modified: trunk/compiler.h
• modified: trunk/debug.c
• modified: trunk/debug.h
• modified: trunk/envspecific.c
• modified: trunk/error.c
• modified: trunk/exception.c
• modified: trunk/file.c
• modified: trunk/float.c
• modified: trunk/function.c
• modified: trunk/globalvars.c
• modified: trunk/help.txt
• modified: trunk/io.c
• modified: trunk/library.c
• modified: trunk/linker.c
• modified: trunk/main.h
• modified: trunk/memory.c
• modified: trunk/operator.c
• modified: trunk/run.c
• modified: trunk/statement.c
• modified: trunk/string.c
• modified: trunk/value.c
• modified: trunk/varname.c

Diff

--- trunk/args.c	(nonexistent)
+++ trunk/args.c	(revision 37)
@@ -0,0 +1,106 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+const unsigned int g_initial_s5_stack[3]={
+	0,                                     // -8($s5): no object
+	(unsigned int) &g_initial_s5_stack[2], // -4($s5): previous $s5 (recursive)
+	0                                      //  0($s5): no parameter
+};
+
+static int g_args_stack;
+/*
+	See ARGS_SP_XXXX and ARGS_S5_XXXX in compiler.h
+	At least 4 stacks are needed even without argument
+		 4($sp) = -12($s5): $sp
+		 8($sp) =  -8($s5): $v0 - pointer to object or previous -8($s5)
+		12($sp) =  -4($s5): previous $s5
+		16($sp) =   0($s5): number of arguments
+		20($sp) =   4($s5): first argument
+	$v0 must be the pointer to an object before comming to this code.
+	After this code, -12($s5) must be set to $sp: 0xAEBDFFF4   sw          sp,-12(s5)
+*/
+char* prepare_args_stack(char start_char){
+	// start_char is either ',' or '('
+	// When ',' mode, there must be a ',' if argument(s) exist(s).
+	// When '(' mode, there shouldn't be a '(', because this character has passed.
+	char* err;
+	int opos,stack;
+	stack=0;
+	opos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BD0000;             // addiu       sp,sp,-xx
+	// 8(sp) is for $v0, which is pointer to an object
+	g_object[g_objpos++]=0xAFA20008;             // sw          v0,8(sp)
+	next_position();
+	do {
+		if (!stack) {
+			// First parameter if exists
+			stack=16;
+			if (start_char==','){
+				if (g_source[g_srcpos]!=',') break;
+			} else if (start_char=='('){
+				next_position();
+				if (g_source[g_srcpos]==')') break;
+				g_srcpos--;
+			} else {
+				return ERR_UNKNOWN;
+			}
+		}
+		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]==',');
+	// 12(sp) is for $s5, 16(sp) is for # of parameters
+	check_obj_space(5);
+	g_object[g_objpos++]=0xAFB5000C;             // sw          s5,12(sp)
+	g_object[g_objpos++]=0x34020000|(stack/4-4); // ori         v0,zero,xx
+	g_object[g_objpos++]=0xAFA20010;             // sw          v0,16(sp)
+	g_object[g_objpos++]=0x27B50010;             // addiu       s5,sp,16
+	g_object[opos]|=((0-stack)&0xFFFF);          // addiu       sp,sp,-xx (See above)
+	// All done. Register # of stacks to global var.
+	g_args_stack=stack;
+	return 0;
+}
+
+char* remove_args_stack(void){
+	// Remove stack
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FB5000C;              // lw          s5,12(sp)
+	g_object[g_objpos++]=0x27BD0000|g_args_stack; // addiu       sp,sp,xx
+	return 0;
+}
+
+char* args_function_main(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<<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++]=0x8C420000;   //   lw          v0,0(v0)
+	}
+	return 0;	
+}
+

--- trunk/class.c	(nonexistent)
+++ trunk/class.c	(revision 37)
@@ -0,0 +1,922 @@
+/*
+   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/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+static int* g_class_structure;
+
+/*
+	CMPDATA_CLASS structure
+		type:      CMPDATA_CLASS (2)
+		len:       3
+		data16:    n/a (0)
+		record[1]: class name as integer
+		record[2]: pointer to class structure
+*/
+
+/*
+	CMPDATA_FIELD structure
+		type:      CMPDATA_FIELD (3)
+		len:       2 or 3 (2: field; 3: method)
+		data16:    field or method
+		             CMPTYPE_PUBLIC_FIELD:  0
+		             CMPTYPE_PRIVATE_FIELD: 1
+		             CMPTYPE_PUBLIC_METHOD: 2
+		record[1]: field/method name as integer
+		record[2]: pointer to method
+*/
+
+/*
+	CMPDATA_STATIC structure
+		type:      CMPDATA_STATIC (4)
+		len:       3
+		data16:    variable number; add ALLOC_LNV_BLOCK when using
+		record[1]: class name as integer
+		record[2]: variable name as integer
+*/
+
+/*
+	CMPDATA_UNSOLVED structure
+		type:      CMPDATA_UNSOLVED (5)
+		len:       4
+		data16:    CMPTYPE_NEW_FUNCTION (0)
+		record[1]: class name as integer
+		record[2]: address of code for pointer to class structure
+		record[3]: address of code for size definition
+
+		type:      CMPDATA_UNSOLVED (5)
+		len:       4
+		data16:    CMPTYPE_STATIC_METHOD (1)
+		record[1]: class name as integer
+		record[2]: method name as integer
+		record[3]: address of code for pointer to method
+
+*/
+
+/*
+	Local prototyping
+*/
+char* obj_method(int method);
+
+/*
+	Return code used for calling null method
+*/
+static const unsigned int g_return_code[]={
+	0x8FA30004, // lw          v1,4(sp)
+	0x00600008, // jr          v1
+	0x27BD0004, // addiu       sp,sp,4
+};
+
+
+
+char* begin_compiling_class(int class){
+	// Initialize parameters
+	g_compiling_class=class;
+	g_class_structure=0;
+	// Register the class to cmpdata without class structure
+	return update_class_info(class);
+}
+
+char* end_compiling_class(int class){
+	char* err;
+	g_compiling_class=0;
+	// Construct class structure
+	err=construct_class_structure(class);
+	if (err) return err;
+	// Uppdate class information.
+	err=update_class_info(class);
+	if (err) return err;
+	// Resolve CMPDATA_UNSOLVED.
+	err=resolve_unresolved(class);
+	if (err) return err;
+	// Delete some cmpdata.
+	delete_cmpdata_for_class(class);
+	return 0;
+}
+
+void* search_method(int* classdata,int method){
+	int pos,i;
+	int nums=classdata[1];
+
+	classdata+=2;                  // exclude first 2 words
+	classdata+=2*(nums&0xff);      // exclude public field
+	classdata+=2*((nums>>8)&0xff); // exclude private field
+	nums=(nums>>16)&0xff;          // number of methods
+	for(i=0;i<nums;i++){
+		if (classdata[0]==method) return (void*)classdata[1];
+		classdata+=2;
+	}
+	return 0; // not found
+}
+
+char* resolve_unresolved(int class){
+	int* classdata;
+	int* record;
+	int* code;
+	int i;
+	// Get class structure
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_CLASS)){
+		if (record[1]==class) break;
+	}
+	if (!record) return ERR_UNKNOWN;
+	classdata=(int*)record[2];
+	// Explore CMPDATA_UNSOLVED
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_UNSOLVED)){
+		// Note: don't use cmpdata_find() again in the loop.
+		// If used, the solved CMPDATA_UNSOLVED must be removed before.
+		if (record[1]!=class) continue;
+		switch (record[0]&0xffff) {
+			case CMPTYPE_NEW_FUNCTION:
+				// Resolve address of code for pointer to class structure
+				code=(int*)(record[2]);
+				code[0]=(code[0]&0xFFFF0000) | (((unsigned int)classdata)>>16);
+				code[1]=(code[1]&0xFFFF0000) | (((unsigned int)classdata) & 0x0000FFFF);
+				// Resolve size of object
+				code=(int*)(record[3]);
+				code[0]=(code[0]&0xFFFF0000) | (object_size(classdata) & 0x0000FFFF);
+				// All done
+				break;
+			case CMPTYPE_STATIC_METHOD:
+				// Resolve address of code for pointer to method
+				// Find method
+				i=(int)search_method(classdata,record[2]);
+				if (!i) return ERR_NOT_FIELD;
+				code=(int*)(record[3]);
+				code[0]=(code[0]&0xFC000000)|((i&0x0FFFFFFF)>>2);
+				// All done
+				break;
+			default:
+				return ERR_UNKNOWN;
+		}
+	}
+	return 0;	
+}
+
+char* update_class_info(int class){
+	int* record;
+	int data[2];
+	// Update record if exist.
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_CLASS)){
+		if (record[1]==class) {
+			record[2]=(int)g_class_structure;
+			return 0;
+		}
+	}
+	// No record of this class yet. Insert a record.
+	data[0]=class;
+	data[1]=(int)g_class_structure;
+	return cmpdata_insert(CMPDATA_CLASS,0,&data[0],2);
+}
+
+/*
+	Class structure:
+		cstruct[0]:   class name as integer
+		cstruct[1]:   number of fields and methods:
+		                bit 0-7:   # of public fields
+		                bit 8-15:  # of private fields
+		                bit 16-23: # of public methods
+		                bit 24-31: reserved
+		cstruct[x]:   public field name
+		cstruct[x+1]: public field var number
+		cstruct[y]:   private field name
+		cstruct[y+1]: private field var number
+		cstruct[z]:   public method name
+		cstruct[z+1]: public method pointer
+*/
+
+char* construct_class_structure(int class){
+	int* record;
+	int i;
+	int num=0;
+	// Register current address to global var
+	g_class_structure=&g_object[g_objpos];
+	// Construct a class structure in object area in following lines
+	// Class name
+	check_obj_space(2);
+	g_object[g_objpos++]=class; // Class name
+	g_objpos++;                 // Number of fields/methods
+	// Public fields
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PUBLIC_FIELD) {
+			num+=1<<0;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Field name
+			g_objpos++;                     // Var number (see below)
+		}
+	}
+	// Private fields
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PRIVATE_FIELD) {
+			num+=1<<8;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Field name
+			g_objpos++;                     // Var number (see below)
+		}
+	}
+	// Public methods
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PUBLIC_METHOD) {
+			num+=1<<16;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Method name
+			g_object[g_objpos++]=record[2]; // pointer
+		}
+	}
+	// Update number info
+	g_class_structure[1]=num;
+	// Update var numbers of fields
+	num=((num>>8)&0xff)+(num&0xff);
+	for(i=1;i<=num;i++){
+		if ((
+			g_class_structure[i*2+1]=search_var_name(0x7FFFFFFF & g_class_structure[i*2])+ALLOC_LNV_BLOCK
+			)<ALLOC_LNV_BLOCK) return ERR_UNKNOWN;
+	}
+	return 0;
+}
+
+void delete_cmpdata_for_class(int class){
+	int* record;
+	// Delete field/method data
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}	
+	// Delete longvar data
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_USEVAR)){
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}
+	// Delete solved class codes
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_UNSOLVED)){
+		if (record[1]!=class) continue;
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}
+}
+
+int object_size(int* classdata){
+	int nums=classdata[1];
+	int size=nums&0xff;   // public field
+	size+=(nums>>8)&0xff; // private
+	// Add 1 for pointer to class data.
+	return size+1;	
+}
+
+char* new_function(){
+	char* err;
+	int class,size;
+	int i,stack, opos;
+	int* data;
+	int* classdata;
+	int record[3];
+	void* init_method;
+	// Resolve class name
+	err=get_label();
+	if (err) return err;
+	if (!g_label) return ERR_SYNTAX;
+	class=g_label;
+	record[0]=class;
+	next_position();
+	// Get class data from cmpdata
+	// Note that the address of class structure can be resolved
+	// by using cmpdata when compiling NEW function but not running. 
+	// Therefore, class table is not requred when running.
+	cmpdata_reset();
+	while(data=cmpdata_find(CMPDATA_CLASS)){
+		if (data[1]==class) break;
+	}
+	if (!data) return ERR_NO_CLASS;
+	classdata=(int*)data[2];
+	if (classdata) {
+		size=object_size(classdata);
+	} else {
+		// Class structure is unsolved.
+		size=0;
+	}
+	// Create object
+	record[2]=(int)&g_object[g_objpos+3];
+	call_quicklib_code(lib_calloc_memory,ASM_ORI_A0_ZERO_|size);
+	// First word of object is pointer to classdata
+	check_obj_space(3);
+	record[1]=(int)&g_object[g_objpos];
+	g_object[g_objpos++]=0x3C080000|(((unsigned int)classdata)>>16);        // lui         t0,xxxx
+	g_object[g_objpos++]=0x35080000|(((unsigned int)classdata)&0x0000FFFF); // ori         t0,t0,xxxx
+	g_object[g_objpos++]=0xAC480000; // sw          t0,0(v0)
+	// Check if INIT method exists
+	if (classdata) {
+		init_method=search_method(classdata,LABEL_INIT);
+	} else {
+		// Class structure is unknown. Use null method.
+		init_method=(int*)&g_return_code[0];
+		// Register CMPDATA
+		cmpdata_insert(CMPDATA_UNSOLVED,CMPTYPE_NEW_FUNCTION,(int*)&record[0],3);
+		g_allow_shift_obj=0;
+	}		
+	if (!init_method) {
+		// All done
+		// Note that $v0 is address of object here.
+		// There should not be parameter(s).
+		if (g_source[g_srcpos]==',') return ERR_NO_INIT;
+		return 0;
+	}
+	// INIT method exists. Note that $v0 is address of object here.
+	if (g_source[g_srcpos]==',') g_srcpos++;
+	else if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	err=obj_method(LABEL_INIT);
+	if (err) return err;
+	g_srcpos--; // Leave ')' character for detecting end of "new" function
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	// All done
+	// Note that $v0 is address of object here.
+	return 0;
+}
+
+char* field_statement(){
+	char* err;
+	int i;
+	int data[1];
+	int is_private=0;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Check which private or public
+	next_position();
+	if (nextCodeIs("PRIVATE ")) {
+		is_private=1;
+	} else if (nextCodeIs("PUBLIC ")) {
+		is_private=0;
+	}
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		// Register varname
+		err=register_var_name(i);
+		if (err) return err;
+		if (g_source[g_srcpos]=='#') {
+			g_srcpos++;
+		} else if (g_source[g_srcpos]=='$') {
+			// String field. Raise 31st bit.
+			g_srcpos++;
+			i|=0x80000000;
+		} else if (g_source[g_srcpos]=='(' && g_source[g_srcpos+1]==')' && is_private) {
+			// Dimension field (private only). Raise 31st bit.
+			g_srcpos++;
+			g_srcpos++;
+			i|=0x80000000;
+		}
+		// Register field
+		data[0]=i;
+		if (is_private) {
+			err=cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PRIVATE_FIELD,(int*)&data[0],1);
+		} else {
+			err=cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PUBLIC_FIELD,(int*)&data[0],1);
+		}
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+/*
+	char* obj_method(int method);
+	Implementation of access to method of object.
+*/
+char* obj_method(int method){
+	// $v0 contains the address of object.
+	// Note that '(' has been passed.
+	char* err;
+	int stack,opos;
+	// When method of an object is called from object, 
+	// current variables must be saved to object fields
+	if (g_compiling_class) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00402821; // addu        a1,v0,zero
+		call_quicklib_code(lib_save_vars_to_fields,ASM_LW_A0_XXXX_S5|ARGS_S5_V0_OBJ);
+	}
+	// Parameters preparation (to $s5) here.
+	next_position();
+	opos=g_objpos;
+	// Begin parameter(s) construction routine
+	err=prepare_args_stack('(');
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	// Determine address of method and store fields to local variables.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA20000|ARGS_SP_V0_OBJ;            // lw          v0,8(sp)
+	g_object[g_objpos++]=0x3C050000|((method>>16)&0x0000FFFF); // lui   a1,xxxx
+	g_object[g_objpos++]=0x34A50000|(method&0x0000FFFF);       // ori a1,a1,xxxx
+	call_quicklib_code(lib_pre_method,ASM_ADDU_A0_V0_ZERO);
+	// Call method address here. Same routine for GOSUB statement with integer value is used.
+	check_obj_space(6);
+	g_object[g_objpos++]=0x27BDFFFC;                           // addiu       sp,sp,-4
+	g_object[g_objpos++]=0x04130003;                           // bgezall     zero,label1
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                // sw          sp,-12(s5)
+	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:
+	// Restore fields from local variables.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA40008;                           // lw          a0,8(sp)
+	call_quicklib_code(lib_post_method,ASM_ADDU_A1_V0_ZERO);
+	// Remove stack
+	err=remove_args_stack();
+	if (err) return err;
+	// When method of an object is called from object, 
+	// current variables must be saved to object fields
+	if (g_compiling_class) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00402821; // addu        a1,v0,zero
+		call_quicklib_code(lib_load_vars_from_fields,ASM_LW_A0_XXXX_S5|ARGS_S5_V0_OBJ);
+	}
+	return 0;
+}
+
+/*
+	char* integer_obj_field();
+	char* string_obj_field();
+	char* float_obj_field();
+	Implementation of access to field of object.
+	This feature is recursive. When an object is applied to the field of another object, 
+	following expression is possible (for example):
+		obj1.field1.field2
+	
+*/
+
+#define OBJ_FIELD_INTEGER 0
+#define OBJ_FIELD_STRING  '$'
+#define OBJ_FIELD_FLOAT   '#'
+
+char* _obj_field(char mode){
+	// $v0 contains the address of object.
+	int i;
+	char* err;
+	do {
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		if (g_source[g_srcpos]=='(' && mode==OBJ_FIELD_INTEGER) {
+			// This is a method
+			g_srcpos++;
+			return obj_method(i);
+		} else if (g_source[g_srcpos+1]=='(') {
+			if (g_source[g_srcpos]==mode) {
+				// This is a string/float method
+				g_srcpos++;
+				g_srcpos++;
+				return obj_method(i);
+			}
+		} else if (g_source[g_srcpos]==mode && mode==OBJ_FIELD_STRING) {
+			// This is a string field. Raise 31st bit.
+			i|=0x80000000;
+		}
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C050000|((i>>16)&0x0000FFFF); // lui   a1,xxxx
+		g_object[g_objpos++]=0x34A50000|(i&0x0000FFFF);       // ori a1,a1,xxxx
+		// First and second arguments are address of object and field name, respectively.
+		call_quicklib_code(lib_obj_field,ASM_ADDU_A0_V0_ZERO);
+		// Check if "." follows
+		if (g_source[g_srcpos]=='.') {
+			// "." found. $v0 is adress of an object. See the field.
+			g_srcpos++;
+			continue;
+		}
+	} while(0);
+	// All done. Check variable type
+	if (mode==OBJ_FIELD_INTEGER) return 0;
+	else if (g_source[g_srcpos]==mode) {
+		g_srcpos++;
+		return 0;
+	} else return ERR_SYNTAX;
+}
+
+char* integer_obj_field(){
+	return _obj_field(OBJ_FIELD_INTEGER);
+}
+
+char* string_obj_field(){
+	return _obj_field(OBJ_FIELD_STRING);
+}
+
+char* float_obj_field(){
+	return _obj_field(OBJ_FIELD_FLOAT);
+}
+
+int lib_obj_field(int* object, int fieldname){
+	int* class;
+	int i,numfield;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// Obtain # of public field
+	numfield=class[1]&0xff;
+	for(i=0;i<numfield;i++){
+		if (class[2+i*2]==fieldname) break;
+	}
+	if (i==numfield) err_not_field(fieldname,class[0]);
+	// Got address of field. Return value as $v0 and address as $v1.
+	g_temp=(int)(&object[1+i]);
+	asm volatile("la $v1,%0"::"i"(&g_temp));
+	asm volatile("lw $v1,0($v1)");
+	return object[1+i];
+}
+
+/*
+	Library for letting string field 
+*/
+
+void lib_let_str_field(char* prev_str, char* new_str){
+	int var_num=get_permanent_var_num();
+	free_perm_str(prev_str);
+	lib_let_str(new_str,var_num);
+	return;
+}
+
+/*
+	Library for calling method statement
+*/
+
+int lib_load_vars_from_fields(int* object, int v0){
+	// Do nothing if no object
+	if (object) lib_pre_method(object,LABEL_INIT);
+	return v0;
+}
+
+int lib_pre_method(int* object, int methodname){
+	int i,num,nums;
+	int* class;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// Save object field values in local variables in class
+	nums=class[1];
+	num=nums&0xff;
+	for(i=0;i<num;i++){
+		// Public fields
+		class+=2;
+		g_var_mem[class[1]]=object[i+1];
+		// When string, move from permanent block
+		if (0x80000000&class[0]) move_from_perm_block_if_exists(class[1]);
+	}
+	num+=(nums>>8)&0xff;
+	for(i=i;i<num;i++){
+		// Private fields
+		class+=2;
+		g_var_mem[class[1]]=object[i+1];
+		// When string/dimension, move from permanent block
+		if (0x80000000&class[0]) move_from_perm_block_if_exists(class[1]);
+	}
+	// Seek method
+	num+=(nums>>16)&0xff;
+	for(i=i;i<num;i++){
+		class+=2;
+		if (class[0]==methodname) break;
+	}
+	if (i==num) {
+		// Method not found
+		if (methodname==LABEL_INIT) {
+			// INIT method not found
+			// Call null function
+			return (int)(&g_return_code[0]);
+		} else {
+			class=(int*)object[0];
+			err_not_field(methodname,class[0]);
+		}
+	}
+	// Method found. return it.
+	return class[1];
+}
+
+int lib_save_vars_to_fields(int* object,int v0){
+	int* class;
+	// Do nothing if no object
+	if (!object) return;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// save vars
+	lib_post_method(object,0);
+	return v0;
+}
+
+int lib_post_method(int* object, int v0){
+	// Note that v0 (a1) contains the return value from a method.
+	int i,num,nums;
+	int* class;
+	// Restore local variables to object field values
+	class=(int*)object[0];
+	nums=class[1];
+	num=nums&0xff;
+	for(i=0;i<num;i++){
+		// Public fields
+		class+=2;
+		object[i+1]=g_var_mem[class[1]];
+		// When string, move to permanent block
+		if (0x80000000&class[0]) {
+			if (g_var_size[class[1]]) move_to_perm_block(class[1]);
+		}
+	}
+	num+=(nums>>8)&0xff;
+	for(i=i;i<num;i++){
+		// Private fields
+		class+=2;
+		object[i+1]=g_var_mem[class[1]];
+		// When string/dimension, move to permanent block
+		if (0x80000000&class[0]) {
+			if (g_var_size[class[1]]) move_to_perm_block(class[1]);
+		}
+	}
+	// all done
+	return v0;
+}
+
+/*
+	Method statement
+*/
+
+char* method_statement(){
+	char* err;
+	int data[2];
+	int opos=g_objpos;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Insert label for setting $s6
+	err=label_statement();
+	if (err) return err;
+	// Register cmpdata
+	data[0]=g_label;
+	data[1]=(int)(&g_object[opos]);
+	return cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PUBLIC_METHOD,(int*)&data[0],2);
+}
+
+/*
+	Delete statement
+*/
+
+char* delete_statement(){
+	char* err;
+	next_position();
+	g_srcpos--;
+	do{
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		call_quicklib_code(lib_delete,ASM_ADDU_A0_V0_ZERO);
+		next_position();
+	} while (g_source[g_srcpos]==',');
+	return 0;
+}
+
+/*
+	Call statement
+*/
+
+char* call_statement(){
+	// Just get an integer value. That is it.
+	return get_value();
+}
+
+/*
+	Static statement
+*/
+
+char* static_statement(){
+	char* err;
+	int* record;
+	int data[2];
+	int i;
+	int is_private=0;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Check which private or public
+	next_position();
+	if (nextCodeIs("PRIVATE ")) {
+		is_private=1;
+	} else if (nextCodeIs("PUBLIC ")) {
+		is_private=0;
+	}
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') {
+			g_srcpos++;
+		}
+		// Register public static field
+		if (is_private) {
+			// This is the same as USEVAR
+			// Register varname
+			err=register_var_name(i);
+			if (err) return err;
+		} else {
+			// Check if there is already a CMPDATA record
+			cmpdata_reset();
+			while(record=cmpdata_find(CMPDATA_STATIC)){
+				if (record[1]!=g_compiling_class) continue;
+				if (record[2]!=i) continue;
+				break;
+			}
+			if (record) {
+				// There is already a record.
+				// Do not allocate new number but use the registered number;
+				i=record[0]&0xffff;
+				err=cmpdata_insert(CMPDATA_USEVAR,i,&record[2],1);
+				if (err) return err;
+			} else {
+				// Register varname
+				err=register_var_name(i);
+				if (err) return err;
+				// Insert a CMDATA_STATIC record
+				data[0]=g_compiling_class; // class name as integer
+				data[1]=i;                 // static var name as integer
+				i=search_var_name(i);      // var number of this static field
+				if (i<0) return ERR_UNKNOWN;
+				err=cmpdata_insert(CMPDATA_STATIC,i,(int*)&data[0],2);
+				if (err) return err;
+			}
+		}
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+	
+}
+
+/*
+	Static method
+		Type is either 0, '$', or '#', 
+		for integer, string, or float
+*/
+
+char* static_method(char type){
+	char* err;
+	int* data;
+	int record[3];
+	int i,opos,method,stack;
+	next_position();
+	// Check class name
+	i=check_var_name();
+	if (i<65536) return ERR_SYNTAX;
+	record[0]=i;
+	// Check if the class exists
+	cmpdata_reset();
+	while(data=cmpdata_find(CMPDATA_CLASS)){
+		if (data[1]==i) {
+			// The class was already defined.
+			i=0;
+			break;
+		}
+	}
+	// Check '::'
+	if (g_source[g_srcpos]!=':') return ERR_SYNTAX;
+	g_srcpos++;
+	if (g_source[g_srcpos]!=':') return ERR_SYNTAX;
+	g_srcpos++;
+	if (i) return ERR_NO_CLASS;
+	data=(int*)data[2];
+	// Check method
+	i=check_var_name();
+	if (i<65536) return ERR_SYNTAX;
+	if (data) {
+		method=(int)search_method(data,i);
+		if (!method) return ERR_NOT_FIELD;
+	} else {
+		method=(int)&g_return_code[0];
+		record[1]=i;
+	}
+	// Check type and '('
+	if (type) {// Either 0, '$', or '#'
+		if (g_source[g_srcpos]!=type) return ERR_SYNTAX;
+		g_srcpos++;
+
+	}
+	if (g_source[g_srcpos]!='(') return ERR_SYNTAX;
+	g_srcpos++;
+	// Begin parameter(s) construction routine
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34020000; // ori v0,zero,0
+	err=prepare_args_stack('(');
+	if (err) return err;
+	// Calling subroutine, which is static method of class
+	record[2]=(int)&g_object[g_objpos+5];
+	check_obj_space(7);
+	g_object[g_objpos++]=0x27BDFFFC;                            // addiu       sp,sp,-4
+	g_object[g_objpos++]=0x04130003;                            // bgezall     zero,label1
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                 // sw          sp,-12(s5)
+	g_object[g_objpos++]=0x10000003;                            // beq         zero,zero,label2
+	g_object[g_objpos++]=0x00000000;                            // nop         
+	                                                            // label1:
+	g_object[g_objpos++]=0x08000000|((method&0x0FFFFFFF)>>2);   // j           xxxx
+	g_object[g_objpos++]=0xAFBF0004;                            // sw          ra,4(sp)
+		                                                        // label2:	
+	// Register CMPDATA if required.
+	if (!data) {
+		cmpdata_insert(CMPDATA_UNSOLVED,CMPTYPE_STATIC_METHOD,(int*)&record[0],3);
+		g_allow_shift_obj=0;
+	}
+	// Remove stack
+	err=remove_args_stack();
+	if (err) return err;
+	return 0;
+}
+
+/*
+	Let object.field statement
+*/
+
+char* let_object_field(){
+	char* err;
+	char b3;
+	int spos,opos;
+	// $v0 contains the pointer to object
+	spos=g_srcpos;
+	opos=g_objpos;
+	// Try string field, first
+	err=string_obj_field();
+	if (err) {
+		// Integer or float field
+		g_srcpos=spos;
+		g_objpos=opos;
+		err=integer_obj_field();
+		if (err) return err;
+		b3=g_source[g_srcpos];
+		if (b3=='#') g_srcpos++;
+	} else {
+		// String field
+		b3='$';
+	}
+	if (g_source[g_srcpos-1]==')') {
+		// This is a CALL statement
+		return 0;
+	}
+	// $v1 is address to store value. Save it in stack.
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+	g_object[g_objpos++]=0xAFA30004;              // sw    v1,4(sp)
+	if (b3=='$') {
+		// String field
+		// Get value
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+	} else if (b3=='#') {
+		// Float field
+		// Get value
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+	} else {
+			// Integer field
+			// Get value
+			next_position();
+			if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+			g_srcpos++;
+			err=get_value();
+	}
+	if (err) return err;
+	// Store in field of object
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+	g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+	g_object[g_objpos++]=0x8C640000;              // lw    a0,0(v1)
+	g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+	// Handle permanent block for string field
+	if (b3=='$') call_quicklib_code(lib_let_str_field,ASM_ADDU_A1_V0_ZERO);
+	return 0;
+}
\ No newline at end of file

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

--- trunk/class.txt	(nonexistent)
+++ trunk/class.txt	(revision 37)

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

--- trunk/cmpdata.c	(revision 36)
+++ trunk/cmpdata.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 /*
@@ -21,10 +25,22 @@
 			data16: general 16 bit data (short)
 */
 
+/*
+	CMPDATA_TEMP structure
+		type:      CMPDATA_TEMP (6)
+		len:       n+1
+		data16:    id
+		record[1]: any data
+		record[2]: any data
+		...
+		record[n]: any data
+*/
+
 #define g_cmpdata g_objmax
 
 static int* g_cmpdata_end;
 static int* g_cmpdata_point;
+static unsigned short g_cmpdata_id;
 
 /*
 	Initialize routine must be called when starting compiler.
@@ -32,9 +48,18 @@
 void cmpdata_init(){
 	g_cmpdata_end=g_objmax;
 	g_cmpdata_point=g_objmax;
+	g_cmpdata_id=1;
 }
 
 /*
+	Returns ID as 16 bit indivisual number
+*/
+unsigned short cmpdata_get_id(){
+	if ((++g_cmpdata_id)==0) printstr("CMPDATA: no more ID!\n");
+	return g_cmpdata_id;
+}
+
+/*
 	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.
@@ -84,3 +109,22 @@
 	cmpdata_reset();
 	return cmpdata_find(type);
 }
+
+/*
+	Delete a record.
+*/
+void cmpdata_delete(int* record){
+	int delnum;
+	int* data;
+	// Ignore if invalid record.
+	if (record<g_cmpdata || g_cmpdata_end<record) return;
+	// Get number of word to delete.
+	delnum=(record[0]&0x00ff0000)>>16;
+	// Delete record by shifting data.
+	for(data=record-1;g_cmpdata<=data;data--){
+	     data[delnum]=data[0];
+	}
+	g_cmpdata+=delnum;
+	// Reset
+	cmpdata_reset();
+}

--- trunk/compiler.c	(revision 36)
+++ trunk/compiler.c	(revision 37)
@@ -5,6 +5,31 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
+	Usage of MIPS32 registors
+	$zero:   always zero
+	$at:     not used
+	$v0:     return value or result of last calculation
+	$v1:     for calculation (like $v0=$v1*$v0)
+	$a0-$a2: parameters for calling library ($a2=$v0)
+	$a3:     function # for library
+	$t0-$t7: used as temporary registors
+	$s0-$s4: not used
+	$s5:     pointer to parameters list
+	$s6:     line or label number
+	$s7:     address of call_library()
+	$t8-$t9: used as temporary registors
+	$k0-$k1: not used
+	$gp:     for accessing global valiables by C
+	$sp:     stack pointer
+	$fp($s8) for accessing valiables by BASIC
+	$ra:     contains return address
+*/
+
 #include "compiler.h"
 
 void start_program(void* addr, void* memory){
@@ -32,6 +57,8 @@
 	asm volatile("la $v0,%0"::"i"(&g_end_addr));
 	asm volatile("la $v1,label");
 	asm volatile("sw $v1,0($v0)");
+	// Set s5 for initial_s5_stack
+	asm volatile("la $s5,%0"::"i"(&g_initial_s5_stack[2]));
 	// Set s7 for easy calling call_library()
 	asm volatile("la $s7,%0"::"i"(&call_library));
 	// Set fp and execute program

--- trunk/compiler.h	(revision 36)
+++ trunk/compiler.h	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 // Include envilonment specific configurations
 #include "envspecific.h"
 
@@ -24,7 +28,7 @@
 // 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
+#define ALLOC_BLOCK_NUM 329
 
 // Persistent RAM bytes used for object, heap and exception data
 #ifndef PERSISTENT_RAM_SIZE
@@ -118,6 +122,9 @@
 	LIB_FILE           =LIB_STEP*48,
 	LIB_PLAYWAVE       =LIB_STEP*49,
 	LIB_PLAYWAVEFUNC   =LIB_STEP*50,
+	LIB_SETDIR         =LIB_STEP*51,
+	LIB_SETDIRFUNC     =LIB_STEP*52,
+	LIB_GETDIR         =LIB_STEP*53,
 	LIB_DEBUG          =LIB_STEP*127,
 };
 
@@ -185,6 +192,7 @@
 extern unsigned int g_label;
 extern int g_sdepth;
 extern int g_maxsdepth;
+extern char g_allow_shift_obj;
 extern enum variable g_lastvar;
 extern char* g_source;
 extern int g_srcpos;
@@ -213,6 +221,8 @@
 extern unsigned short* g_graphic_area;
 extern int* g_libparams;
 extern int g_long_name_var_num;
+extern int g_class;
+extern int g_compiling_class;
 extern int g_temp;
 
 /* Prototypes */
@@ -228,6 +238,9 @@
 void close_file();
 void read_file(int blocklen);
 char* compile_file();
+int compile_and_link_file(char* buff,char* appname);
+int compile_and_link_main_file(char* buff,char* appname);
+int compile_and_link_class(char* buff,int class);
 
 void err_break(void);
 void err_music(char* str);
@@ -242,6 +255,9 @@
 void err_invalid_param(void);
 void err_file(void);
 void err_wave(void);
+void err_not_obj(void);
+void err_not_field(int fieldname, int classname);
+void err_str(char* str);
 char* resolve_label(int s6);
 
 void set_sound(unsigned long* data, int flagsLR);
@@ -260,6 +276,7 @@
 char* fput_statement();
 char* fputc_statement();
 char* fremove_statement();
+char* label_statement();
 
 char* function(void);
 char* str_function(void);
@@ -269,11 +286,17 @@
 void reset_dataread();
 
 void free_temp_str(char* str);
+void free_non_temp_str(char* str);
+void free_perm_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 move_from_perm_block_if_exists(int var_num);
 int get_permanent_var_num(void);
+int get_varnum_from_address(void* address);
+void* lib_calloc_memory(int size);
+void lib_delete(int* object);
 
 char* link(void);
 char* get_label(void);
@@ -301,10 +324,12 @@
 char* get_float();
 
 void cmpdata_init();
+unsigned short cmpdata_get_id();
 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);
+void cmpdata_delete(int* record);
 
 int check_var_name();
 int get_var_number();
@@ -311,7 +336,37 @@
 int search_var_name(int nameint);
 char* register_var_name(int nameint);
 
+char* update_class_info(int class);
+char* construct_class_structure(int class);
+void delete_cmpdata_for_class(int class);
 
+extern const unsigned int g_initial_s5_stack[3];
+char* prepare_args_stack(char start_char);
+char* remove_args_stack(void);
+char* args_function_main(void);
+
+char* begin_compiling_class(int class);
+char* end_compiling_class(int class);
+char* new_function();
+char* field_statement();
+char* integer_obj_field();
+char* string_obj_field();
+char* float_obj_field();
+int lib_obj_field(int* object, int fieldname);
+int lib_pre_method(int* object, int methodname);
+int lib_post_method(int* object, int v0);
+int lib_save_vars_to_fields(int* object,int v0);
+int lib_load_vars_from_fields(int* object, int v0);
+
+char* method_statement();
+char* delete_statement();
+char* call_statement();
+void lib_let_str_field(char* str, char* prev_str);
+char* let_object_field();
+char* static_statement();
+char* static_method(char type);
+char* resolve_unresolved(int class);
+
 /* Error messages */
 #define ERR_SYNTAX (char*)(g_err_str[0])
 #define ERR_NE_BINARY (char*)(g_err_str[1])
@@ -335,13 +390,51 @@
 #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])
+#define ERR_COMPILE_CLASS (char*)(g_err_str[22])
+#define ERR_NO_CLASS (char*)(g_err_str[23])
+#define ERR_NOT_OBJ (char*)(g_err_str[24])
+#define ERR_NOT_FIELD (char*)(g_err_str[25])
+#define ERR_INVALID_NON_CLASS (char*)(g_err_str[26])
+#define ERR_INVALID_CLASS (char*)(g_err_str[27])
+#define ERR_NO_INIT (char*)(g_err_str[28])
 
-/* comple data type numbers */
+/* compile data type numbers */
 #define CMPDATA_RESERVED 0
 #define CMPDATA_USEVAR   1
+#define CMPDATA_CLASS    2
+#define CMPDATA_FIELD    3
+#define CMPDATA_STATIC   4
+#define CMPDATA_UNSOLVED 5
+#define CMPDATA_TEMP     6
+// Sub types follow
+#define CMPTYPE_PUBLIC_FIELD 0
+#define CMPTYPE_PRIVATE_FIELD 1
+#define CMPTYPE_PUBLIC_METHOD 2
+#define CMPTYPE_NEW_FUNCTION 0
+#define CMPTYPE_STATIC_METHOD 1
 
+
+/* Stack position for values in args.c */
+#define ARGS_SP_SP       4
+#define ARGS_SP_V0_OBJ   8
+#define ARGS_SP_PREV_S5  12
+#define ARGS_SP_NUM_ARGS 16
+#define ARGS_S5_SP       (-12 & 0xFFFF)
+#define ARGS_S5_V0_OBJ   (-8  & 0xFFFF)
+#define ARGS_S5_PREV_S5  (-4  & 0xFFFF)
+#define ARGS_S5_NUM_ARGS (0   & 0xFFFF)
+
+/*
+	Hidden varname 31 bit values
+	Note that max number of 31 bit value is 0x61504BFF (for ZZZZZZ)
+*/
+#define HIDDEN_VAR_THIS_OBJECT 0x7FFF0000
+
 /* Macros */
 
+// Lables as 31 bit integer
+#define LABEL_INIT 0x0007df55
+
 // Skip blanc(s) in source code
 #define next_position() while(g_source[g_srcpos]==' ') {g_srcpos++;}
 
@@ -359,6 +452,28 @@
 	g_object[g_objpos++]=0x02E0F809;\
 	g_object[g_objpos++]=0x24070000|((x)&0x0000FFFF)
 
+// Insert code for calling quick library
+//3C081234   lui         t0,0x1234
+//35085678   ori         t0,t0,0x5678
+//0100F809   jalr        ra,t0
+//00000000   nop         
+#define call_quicklib_code(x,y) do {\
+		check_obj_space(4);\
+		g_object[g_objpos++]=0x3C080000|(((unsigned int)(x))>>16);\
+		g_object[g_objpos++]=0x35080000|(((unsigned int)(x))&0x0000FFFF);\
+		g_object[g_objpos++]=0x0100F809;\
+		g_object[g_objpos++]=(y);\
+	} while (0)	
+
+#define ASM_NOP 0x00000000
+#define ASM_ADDU_A0_V0_ZERO 0x00402021
+#define ASM_ADDU_A1_V0_ZERO 0x00402821
+#define ASM_ADDU_A2_V0_ZERO 0x00403021
+#define ASM_ADDU_A3_V0_ZERO 0x00403821
+#define ASM_ORI_A0_ZERO_ 0x34040000
+#define ASM_LW_A0_XXXX_S8 0x8FC40000
+#define ASM_LW_A0_XXXX_S5 0x8EA40000
+
 // 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))
@@ -374,3 +489,6 @@
 // Divide by 36 (valid for 32 bits)
 #define div36_32(x) div32(x,0xe38e38e4,37)
 #define rem36_32(x) (x-36*div36_32(x))
+
+// Check if within RAM
+#define withinRAM(x) ((&RAM[0])<=((char*)(x)) && ((char*)(x))<(&RAM[RAMSIZE]))

--- trunk/debug.c	(revision 36)
+++ trunk/debug.c	(revision 37)
@@ -32,6 +32,8 @@
 
 static const char initext[];
 static const char bastext[];
+static const char class1text[];
+static const char class2text[];
 
 static char* readtext;
 static int filepos;
@@ -129,8 +131,15 @@
 		// 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];
+		// Select BAS file
+		if (fileName[i-6]=='C' && fileName[i-5]=='L' && fileName[i-4]=='A' &&
+			fileName[i-3]=='S' && fileName[i-2]=='S') {
+			if (fileName[i-1]=='1') readtext=(char*)&class1text[0];
+			else if (fileName[i-1]=='2') readtext=(char*)&class2text[0];
+			else readtext=(char*)&bastext[0];
+		} else {
+			readtext=(char*)&bastext[0];
+		}
 		// Try debugDump.
 		if (debugDump()) return 0;
 	} else {
@@ -218,29 +227,60 @@
 "#PRINT\n"
 "#PRINT\n";
 
-
 static const char bastext[]=
-"I2C 100\n"
-"DIM D(5)\n"
-"T$=\"Hello MachiKania!\"\n"
-"I2CREADDATA 0x50,D,18,0x00,0x00\n"
-"PRINT I2CERROR()\n"
-"PRINT D$\n"
-"I2CWRITEDATA 0x50,T,18,0x00,0x00\n"
-"PRINT I2CERROR()\n"
-"WAIT 60\n"
-"I2CREADDATA 0x50,D,18,0x00,0x00\n"
+"print getdir$()\n"
+"end\n"
 "\n"
+"\n"
+"\n"
+"\n"
+"\n"
 "\n";
 
+static const char class1text[]=
+"STATIC T1\n"
+"useclass CLASS2\n"
+"method T3\n"
+" return CLASS2::T2\n"
+"method T5\n"
+" return T1\n"
+"\n"
+"\n";
+
+static const char class2text[]=
+"STATIC T2\n"
+"useclass CLASS1\n"
+"method T4\n"
+" return CLASS1::T1\n"
+"method T6\n"
+" return T2\n"
+"\n"
+"\n"
+"\n"
+"\n";
+
 /*
     Test function for constructing assemblies from C codes.
 */
 
+static const void* debugjumptable[]={
+	FSfread,
+	FSfopen,
+};
+
 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");
+	asm volatile(".set noreorder");
+	asm volatile("lw $a0,4($s5)");
+	asm volatile("lw $a1,8($s5)");
+	asm volatile("lw $a2,12($s5)");
+	asm volatile("lw $a3,16($s5)");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
 	return a2+a3;
 }
 

--- trunk/debug.h	(revision 36)
+++ trunk/debug.h	(revision 37)
@@ -5,6 +5,10 @@
    http://hp.vector.co.jp/authors/VA016157/
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #ifdef __DEBUG
 
 // Pseudo reading config setting for debug mode

--- trunk/envspecific.c	(revision 36)
+++ trunk/envspecific.c	(revision 37)
@@ -107,7 +107,7 @@
 			return;
 		} else {
 			// Clear previous area here
-			free_temp_str((char*)g_graphic_area);
+			free_non_temp_str((char*)g_graphic_area);
 			g_graphic_area=0;
 		}
 	}

--- trunk/error.c	(revision 36)
+++ trunk/error.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 const char* g_err_str[]={
@@ -30,6 +34,13 @@
 	"File error",
 	"Invalid variable name",
 	"WAVE format error",
+	"ERR_COMPILE_CLASS",
+	"Class not found",
+	"Not an object",
+	" is not public field/method",
+	"Valid only in class file",
+	"Invalid in class file",
+	"INIT method does not exist",
 };
 
 char* resolve_label(int s6){
@@ -168,3 +179,20 @@
 	end_exec();	
 }
 
+void err_not_obj(void){
+	printstr(ERR_NOT_OBJ);
+	end_exec();	
+}
+
+void err_not_field(int fieldname, int classname){
+	printstr(resolve_label(classname));
+	printchar('.');
+	printstr(resolve_label(fieldname & 0x7FFFFFFF));
+	printstr(ERR_NOT_FIELD);
+	end_exec();	
+}
+
+void err_str(char* str){
+	printstr(str);
+	end_exec();	
+}
\ No newline at end of file

--- trunk/exception.c	(revision 36)
+++ trunk/exception.c	(revision 37)
@@ -5,6 +5,10 @@
    http://hp.vector.co.jp/authors/VA016157/
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include <xc.h>
 #include "api.h"
 #include "main.h"

--- trunk/file.c	(revision 36)
+++ trunk/file.c	(revision 37)
@@ -5,6 +5,10 @@
    http://hp.vector.co.jp/authors/VA016157/
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include <xc.h>
 #include "api.h"
 #include "compiler.h"
@@ -19,9 +23,12 @@
 	if (!g_fhandle) {
 		return ERR_UNKNOWN;
 	}
+	// Initialize parameters
 	g_fbuff=buff;
 	g_line=0;
 	g_fileline=0;
+	g_source=buff;
+	g_srcpos=0;
 	return 0;
 }
 
@@ -88,7 +95,11 @@
 		if (err) return err;
 	}
 	// Add "DATA 0" and "END" statements.
-	g_source="DATA 0:END\n";
+	if (g_compiling_class) {
+		g_source="END\n";
+	} else {
+		g_source="DATA 0:END\n";
+	}
 	g_srcpos=0;
 	err=compile_line();
 	if (err) return err;
@@ -97,3 +108,165 @@
 	return 0;
 }
 
+int compile_and_link_file(char* buff,char* appname){
+	int i,j;
+	char* err;
+
+	while(1){
+		// 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;
+		}
+	
+		// Compile the file
+		err=compile_file();
+		close_file();
+
+		// If compiling a class file is required, do it.
+		if (err==ERR_COMPILE_CLASS) {
+			j=g_compiling_class;
+			i=compile_and_link_class(buff, g_class);
+			g_compiling_class=j;
+			if (i) return i;
+			// Continue compiling current file from the beginning.
+			continue;
+		}
+		break;
+	}
+
+	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
+	return 0;
+}
+
+int compile_and_link_class(char* buff,int class){
+	int i,j;
+	char* err;
+	char* classname;
+	char classfile[13];
+	char classdir[11];
+	int data[2];
+	unsigned short cwd_id;
+	int* record;
+	while(1){
+		// Begin compiling class
+		err=begin_compiling_class(class);
+		if (err) break;
+		// Determine class file name
+		classname=resolve_label(class);
+		for(i=0;classfile[i]=classname[i];i++);
+		classfile[i++]='.';
+		classfile[i++]='B';
+		classfile[i++]='A';
+		classfile[i++]='S';
+		classfile[i]=0;
+		// Check if file exists in current directory
+		err=init_file(buff,&classfile[0]);
+		if (!err) {
+			// Class file found in current directory
+			close_file();
+			// Compile it
+			i=compile_and_link_file(buff,&classfile[0]);
+			if (i) break;
+		} else {
+			// Class file not found in current directory.
+			// Try library directory, for example, \LIB\CLASS1\CLASS1.BAS
+			// Store current directory, first
+			if (!FSgetcwd(buff,256)) break;
+			for(i=0;buff[i];i++);
+			cwd_id=cmpdata_get_id();
+			if (!cwd_id) break;
+			err=cmpdata_insert(CMPDATA_TEMP,cwd_id,(int*)(&buff[0]),(i+1+3)>>2);
+			if (err) break;
+			// Change current directory to class library directory
+			for(i=0;classdir[i]="\\LIB\\"[i];i++);
+			for(j=0;classdir[i++]=classname[j];j++);
+			classdir[i]=0;
+			FSchdir(classdir);
+			// Compile class file
+			i=compile_and_link_file(buff,&classfile[0]);
+			// Restore current dirctory
+			cmpdata_reset();
+			while(record=cmpdata_find(CMPDATA_TEMP)){
+				if (cwd_id=(record[0]&0xffff)) break;
+			}
+			if (!record) break;
+			FSchdir((char*)(&record[1]));
+			cmpdata_delete(record);
+			if (i) break;
+		}
+		// End compiling class
+		err=end_compiling_class(class);
+		if (err) break;
+		// Initial assembly is a jump statement to jump to the end of class file
+		// Note that there is at least a code (set line # to $s6) before reaching here
+		g_object[0]=0x08000000 | ((((int)(&g_object[g_objpos]))&0x0FFFFFFF)>>2); // j xxxxxxxx
+		// In the next link, current region of object is ignored.
+		g_object+=g_objpos;
+		g_objpos=0;
+		// All done
+		return 0;
+	}
+	// Error occured
+	printstr("/nError in class: ");
+	printstr((char*)&classfile[0]);
+	printchar('\n');
+	if (err) printstr(err);
+	return -2;
+}
+
+int compile_and_link_main_file(char* buff,char* appname){
+	int i;
+	g_compiling_class=0;
+	i=compile_and_link_file(buff,appname);
+	if (i) return i;
+	return 0;
+	/*
+		After compiling class code, g_object is set to the beginning of next code.
+		Therefore, after the all, g_object is set toe the beginnig of main code,
+		and class code(s) is/are excluded. This will affect following features when running:
+			READ/DATA/RESTORE function/statements
+		The linker also works withing the g_object dimension. Therefore, the label only works withing the file,
+		but not in the other file. This feature allows using the same label name in different files without
+		causing error/misjumping
+
+		After compiling class code, following cmpdata are destroyed (see delete_cmpdata_for_class() function):
+			CMPDATA_FIELD  : object field and method information
+			CMPDATA_USEVAR : long var name information
+		but following cmpdata remains:
+			CMPDATA_CLASS  : class name and address of class structure
+		This feature allows compiler to use class information (name and structure) for "NEW" function,
+		to use the same long var name in different files (note that g_long_name_var_num is not reseted after
+		compiling each class code).
+	*/
+}
\ No newline at end of file

--- trunk/float.c	(revision 36)
+++ trunk/float.c	(revision 37)
@@ -1,3 +1,14 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "./compiler.h"
 #include "stdlib.h"
 
@@ -57,6 +68,21 @@
 				// Must be a function.
 				return float_function();
 			}
+			if (g_source[g_srcpos]=='.') {
+				// This is an object field or method to return string
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+				g_srcpos++;
+				return float_obj_field();
+			} else if (g_source[g_srcpos]=='(') {
+				// An array element contains pointer to an object.
+				g_srcpos++;
+				err=get_dim_value(i);
+				if (err) return err;
+				if (g_source[g_srcpos]!='.') return ERR_SYNTAX;
+				g_srcpos++;
+				return float_obj_field();
+			}
 			if (g_source[g_srcpos]!='#') return ERR_SYNTAX;
 			g_srcpos++;
 			if (g_source[g_srcpos]=='(') {
@@ -122,7 +148,7 @@
 		prevpos=g_objpos;
 		// Stack decrement command will be filled later
 		check_obj_space(1);
-		g_objpos++;
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
 	}
 	err=get_float_sub(priority(OP_VOID));
 	if (err) return err;
@@ -129,8 +155,10 @@
 	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--;
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
 		} else {
 			// Stack was used.
 			check_obj_space(1);

--- trunk/function.c	(revision 36)
+++ trunk/function.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 #include "api.h"
 
@@ -23,6 +27,8 @@
 }
 
 char* read_function(){
+	// This function is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
 	call_lib_code(LIB_READ);
 	return 0;
 }
@@ -92,12 +98,23 @@
 	return 0;	
 }
 
-char* peek_function(){
+char* peek_function_sub(int bits){
 	char* err;
 	err=get_value();
 	if (err) return err;
 	check_obj_space(1);
-	g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+	switch(bits){
+		case 32:
+			g_object[g_objpos++]=0x8C420000; // lw          v0,0(v0)
+			break;
+		case 16:
+			g_object[g_objpos++]=0x94420000; // lhu         v0,0(v0)
+			break;
+		case 8:
+		default:
+			g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+			break;
+	}
 	return 0;
 }
 
@@ -244,23 +261,7 @@
 }
 
 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;	
+	return args_function_main();
 }
 
 char* system_function(void){
@@ -378,6 +379,19 @@
 	return 0;
 }
 
+char* setdir_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_SETDIRFUNC);
+	return 0;
+}
+
+char* getdir_function(){
+	call_lib_code(LIB_GETDIR);
+	return 0;
+}
+
 char* float_constant(float val){
 	volatile int i;
 	((float*)(&i))[0]=val;
@@ -475,7 +489,9 @@
 	} else if (nextCodeIs("PI#")) {
 		return float_constant(3.141593);
 	} else {
-		return ERR_SYNTAX;
+		// Check if static method of a class
+		err=static_method('#');
+		//return ERR_SYNTAX;
 	}
 	if (err) return err;
 	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
@@ -495,6 +511,7 @@
 	"FLOAT$(",floatstr_function,
 	"SYSTEM$(",system_function,
 	"FINPUT$(",finput_function,
+	"GETDIR$(",getdir_function,
 	// Additional functions follow
 	ADDITIONAL_STR_FUNCTIONS
 };
@@ -512,7 +529,9 @@
 		f=str_func_list[i+1];
 		err=f();
 	} else {
-		return ERR_SYNTAX;
+		// Check if static method of a class
+		err=static_method('$');
+		//return ERR_SYNTAX;
 	}
 	if (err) return err;
 	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
@@ -522,6 +541,18 @@
 
 // Aliases follow
 
+char* peek_function(){
+	return peek_function_sub(8);
+}
+
+char* peek16_function(){
+	return peek_function_sub(16);
+}
+
+char* peek32_function(){
+	return peek_function_sub(32);
+}
+
 char* gcolor_function(){
 	return graphic_statement(FUNC_GCOLOR);
 }
@@ -541,6 +572,8 @@
 	"GOSUB(",gosub_function,
 	"STRNCMP(",strncmp_function,
 	"PEEK(",peek_function,
+	"PEEK16(",peek16_function,
+	"PEEK32(",peek32_function,
 	"LEN(",len_function,
 	"ASC(",asc_function,
 	"SGN(",sgn_function,
@@ -562,6 +595,8 @@
 	"FREMOVE(",fremove_statement,
 	"FEOF(",feof_function,
 	"PLAYWAVE(",playwave_function,
+	"NEW(",new_function,
+	"SETDIR(",setdir_function,
 	// Additional functions follow
 	ADDITIONAL_INT_FUNCTIONS
 };
@@ -579,7 +614,9 @@
 		f=int_func_list[i+1];
 		err=f();
 	} else {
-		return ERR_SYNTAX;
+		// Check if static method of a class
+		err=static_method(0);
+		//return ERR_SYNTAX;
 	}
 	if (err) return err;
 	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;

--- trunk/globalvars.c	(revision 36)
+++ trunk/globalvars.c	(revision 37)
@@ -5,6 +5,10 @@
    http://hp.vector.co.jp/authors/VA016157/
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 #include "main.h"
 
@@ -24,6 +28,7 @@
 // handling values and strings.
 int g_sdepth;
 int g_maxsdepth;
+char g_allow_shift_obj;
 
 // Following var shows what type of variable was defined
 // in compiling the last code.
@@ -75,5 +80,10 @@
 // Number of long name variables
 int g_long_name_var_num;
 
+// Class name being compiled
+int g_class;
+// Flag to compile class file
+int g_compiling_class;
+
 // General purpose integer used for asigning value with pointer
 int g_temp;

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

--- trunk/io.c	(revision 36)
+++ trunk/io.c	(revision 37)
@@ -57,13 +57,13 @@
 		IEC1bits.U1TXIE=0;
 		IEC1bits.U1RXIE=0;
 		// Free buffer area
-		if (g_serial_buff) free_temp_str((char*)g_serial_buff);
+		if (g_serial_buff) free_non_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);
+		if (g_serial_buff) free_non_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

--- trunk/library.c	(revision 36)
+++ trunk/library.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include <xc.h>
 #include "main.h"
 #include "compiler.h"
@@ -21,6 +25,20 @@
 static int g_prev_x=0;
 static int g_prev_y=0;
 
+int lib_setdir(int mode,char* path){
+	int ret;
+	ret=FSchdir(path);
+	if (mode==LIB_SETDIR && ret) err_file();
+	return ret;
+}
+
+int lib_getdir(){
+	char* path;
+	path=calloc_memory(32,-1);
+	FSgetcwd (path,128);
+	return (int)path;
+}
+
 int lib_read(int mode, unsigned int label){
 	unsigned int i,code,code2;
 	static unsigned int pos=0;
@@ -405,7 +423,7 @@
 		case 2:
 			// Reset PCG and use it
 			if (g_pcg_font) {
-				free_temp_str(g_pcg_font);
+				free_non_temp_str(g_pcg_font);
 				g_pcg_font=0;
 			}
 			// Continue to case 1:
@@ -1012,6 +1030,11 @@
 		case LIB_SETDRAWCOUNT:
 			drawcount=(v0&0x0000FFFF);
 			return v0;
+		case LIB_GETDIR:
+			return lib_getdir();
+		case LIB_SETDIRFUNC:
+		case LIB_SETDIR:
+			return lib_setdir(a3,(char*)v0);
 		case LIB_DRAWCOUNT:
 			return drawcount;
 		case LIB_SYSTEM:

--- trunk/linker.c	(revision 36)
+++ trunk/linker.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 unsigned int g_label;

--- trunk/main.h	(revision 36)
+++ trunk/main.h	(revision 37)
@@ -7,8 +7,8 @@
 
 #define MEGALOPA
 #define SYSVER1 "Megalopa"
-#define SYSVER2 "1.1"
-#define BASVER "KM-1301"
+#define SYSVER2 "1.2"
+#define BASVER "KM-1302"
 
 #define INIFILE "MACHIKAM.INI" // 初期設定ファイル
 #define HEXFILE "MACHIKAM.HEX" // 実行中HEXファイル名がこれと一致した場合はエディタ起動

--- trunk/memory.c	(revision 36)
+++ trunk/memory.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 /*
@@ -13,17 +17,35 @@
 	                  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.
+	                  This # includes the ones for ALLOC_VAR_NUM, ALLOC_PCG_BLOCK etc, ALLOC_LNV_BLOCK,
+	                  ALLOC_PERM_BLOCK.
 	                  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.
 */
 
+static int g_temp_var_num_candidate=ALLOC_PERM_BLOCK;
+
+#define DELETE_LIST_SIZE 10
+static int g_deleted_num;
+static int g_deleted_pointer[DELETE_LIST_SIZE];
+static int g_deleted_size[DELETE_LIST_SIZE];
+
+void register_deleted_block(int pointer, int size){
+	// There is maximum
+	if (DELETE_LIST_SIZE<=g_deleted_num) return;
+	if (g_deleted_num) {
+		// Avoid duplication
+		if (g_deleted_pointer[g_deleted_num-1]==pointer) return;
+	}
+	g_deleted_pointer[g_deleted_num]=pointer;
+	g_deleted_size[g_deleted_num]=size;
+	g_deleted_num++;
+} 
+
 void set_free_area(void* begin, void* end){
+	// Initialize heap area
 	int i;
 	for(i=0;i<ALLOC_BLOCK_NUM;i++){
 		g_var_size[i]=0;
@@ -30,6 +52,7 @@
 	}
 	g_heap_mem=(int*)begin;
 	g_max_mem=(int)((end-begin)/4);
+	g_deleted_num=0;
 }
 
 void* calloc_memory(int size, int var_num){
@@ -85,6 +108,24 @@
 	g_var_size[var_num]=0;
 	g_var_pointer[var_num]=0;
 	while(1){
+		// Try the block previously deleted, not for temporary block.
+		// This is for fast allocation of memory for class object.
+		if (var_num<26 || ALLOC_VAR_NUM<=var_num) {
+			candidate=0;
+			while(g_deleted_num){
+				// Check if the last deleted block fits
+				// If not, these cannot be used anymore
+				g_deleted_num--;
+				if (size<=g_deleted_size[g_deleted_num]) {
+					candidate=g_deleted_pointer[g_deleted_num];
+					break;
+				}
+			}
+			if (candidate || g_deleted_num) {
+				// Candidate found
+				break;
+			}
+		}
 		// Try the block after last block
 		candidate=0;
 		for(i=0;i<ALLOC_BLOCK_NUM;i++){
@@ -93,7 +134,29 @@
 				candidate=g_var_pointer[i]+g_var_size[i];
 			}
 		}
-		if (candidate+size<=g_max_mem) break;
+		if (candidate+size<=g_max_mem) {
+			// Check after deleted block
+			j=candidate;
+			for(i=0;i<g_deleted_num;i++){
+				if (j<g_deleted_pointer[i]+g_deleted_size[i]) {
+					j=g_deleted_pointer[i]+g_deleted_size[i];
+				}
+			}
+			if (j+size<=g_max_mem) {
+				// Candidate block found after previously deleted blokcs
+				candidate=j;
+				break;
+			} else {
+				// Candidate is before previously deleted blocks,
+				// and there is no candidate block after previously deleted blocks.
+				// Therefore, use the current candidate, which may invade previously
+				// deleted blocks. Therefore, erase the previously deleted blocks list.
+				g_deleted_num=0;
+				break;
+			}
+		}
+		// Peviously deleted blocks cannot be used any more
+		g_deleted_num=0;
 		// 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++){
@@ -132,21 +195,64 @@
 	if (!str) return;
 	pointer=(int)str-(int)g_heap_mem;
 	pointer>>=2;
-	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+	for(i=26;i<ALLOC_VAR_NUM;i++){
 		if (g_var_pointer[i]==pointer) {
-			g_var_size[i]=0;
-			break;
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+			}
 		}
 	}
 }
 
+void free_non_temp_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	for(i=0;i<26;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_var_mem[i]=0;
+			}
+		}
+	}
+	for(i=ALLOC_VAR_NUM;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_var_mem[i]=0;
+				if (ALLOC_PERM_BLOCK<=i) g_temp_var_num_candidate=i;
+			}
+		}
+	}
+}
+
+void free_perm_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	// Search permanent block and delete a block if found.
+	for(i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_temp_var_num_candidate=i;
+				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
+	i=get_permanent_var_num();
 	// Available block found.
 	// Copy value from variable.
 	g_var_size[i]=g_var_size[var_num];
@@ -157,7 +263,7 @@
 	g_var_mem[var_num]=0;
 }
 
-void move_from_perm_block(int var_num){
+int move_from_perm_block_if_exists(int var_num){
 	int i,pointer;
 	pointer=(int)g_var_mem[var_num]-(int)g_heap_mem;
 	pointer>>=2;
@@ -165,7 +271,7 @@
 	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
+	if (ALLOC_BLOCK_NUM<=i) return 0; // Not found
 	// Stored block found.
 	// Replace pointer
 	g_var_size[var_num]=g_var_size[i];
@@ -172,13 +278,50 @@
 	g_var_pointer[var_num]=g_var_pointer[i];
 	// Clear block
 	g_var_size[i]=0;
+	g_temp_var_num_candidate=i;
+	return 1;
 }
 
+void move_from_perm_block(int var_num){
+	if (move_from_perm_block_if_exists(var_num)) return; // Found
+	err_unknown(); // Not found
+}
+
 int get_permanent_var_num(){
 	int i;
+	// Try candidate first
+	if (!g_var_size[g_temp_var_num_candidate]) {
+		if (ALLOC_PERM_BLOCK<g_temp_var_num_candidate && 
+				g_temp_var_num_candidate<ALLOC_BLOCK_NUM) {
+			return g_temp_var_num_candidate++;
+		}
+	}
+	// Candidate is not available. Seek all.
 	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++) {
-		if (g_var_size[i]==0) return i;
+		if (g_var_size[i]==0) {
+			g_temp_var_num_candidate=i+1;
+			return i;
+		}
 	}
 	err_no_block();
 	return 0;
 }
+
+int get_varnum_from_address(void* address){
+	int i;
+	for (i=0;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_mem[i]==(int)address) return i;
+	}
+	// not found
+	return -1;
+}
+
+void* lib_calloc_memory(int size){
+	// Allocate memory and return address
+	return calloc_memory(size,get_permanent_var_num());
+}
+
+void lib_delete(int* object){
+	// Remove region that fit to object
+	free_non_temp_str((char*)object);
+}

--- trunk/operator.c	(revision 36)
+++ trunk/operator.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 /*

--- trunk/run.c	(revision 36)
+++ trunk/run.c	(revision 37)
@@ -5,6 +5,10 @@
    http://hp.vector.co.jp/authors/VA016157/
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include <xc.h>
 #include "api.h"
 #include "compiler.h"
@@ -44,10 +48,8 @@
 
 	// Set grobal pointer
 	g_gp=get_gp();
-	// Set source positions
+	// Set buffer 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;
@@ -54,7 +56,8 @@
 	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
+
+	// Check file error
 	err=init_file(buff,appname);
 	if (err) {
 		setcursorcolor(COLOR_ERRORTEXT);
@@ -63,6 +66,7 @@
 		printchar('\n');
 		return -1;
 	}
+	close_file();	
 
 	// Initialize parameters
 	g_pcg_font=0;
@@ -82,34 +86,9 @@
 	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;
-	}
+	i=compile_and_link_main_file(buff,appname);
+	if (i) return i;
 
-	// 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; //コンパイルのみの場合

--- trunk/statement.c	(revision 36)
+++ trunk/statement.c	(revision 37)
@@ -1,1646 +1,1743 @@
-/*
-   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 spos;
-	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++;
-		spos=g_srcpos;
-		err=get_label();
-		if (g_label && !err) {
-			if (search_var_name(g_label)!=-1) {
-				// This is a long var name.
-				g_label=0;
-				g_srcpos=spos;
-			}
-		}
-		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;
-}
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#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(0xE0 & 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;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	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;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	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_sub(int bits){
+	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
+	switch(bits){
+		case 32:
+			g_object[g_objpos++]=0xAC620000; // sw          v0,0(v1)
+			break;
+		case 16:
+			g_object[g_objpos++]=0xA4620000; // sh          v0,0(v1)
+			break;
+		case 8:
+		default:
+			g_object[g_objpos++]=0xA0620000; // sb          v0,0(v1)
+			break;
+	}
+	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;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	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(7);
+		g_object[g_objpos++]=0x27BDFFFC;                            // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x04130003;                            // bgezall     zero,label1
+		g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                 // sw          sp,-12(s5)
+		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(7);
+		g_object[g_objpos++]=0x27BDFFFC;            // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x04130003;            // bgezall     zero,label1
+		g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP; // sw          sp,-12(s5)
+		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;
+	// Skip label first (see below)
+	opos=g_objpos;
+	spos=g_srcpos;
+	err=gosub_statement_sub();
+	if (err) return err;
+	next_position();
+	// Rewind object and construct argument-creating routine.
+	g_objpos=opos;
+	// Begin parameter(s) construction routine
+	g_object[g_objpos++]=0x8EA20000|ARGS_S5_V0_OBJ;           // lw          v0,-8(s5)
+	err=prepare_args_stack(',');
+	if (err) return err;
+	// 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
+	err=remove_args_stack();
+	if (err) return err;
+	// All done, go back to right 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(4);
+	g_object[g_objpos++]=0x8EBD0000|ARGS_S5_SP; // lw          sp,-12(s5)
+	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,spos,opos;
+	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);
+		if (g_source[g_srcpos]=='.') {
+			// This is an object. Determine the filed of this object.
+			// 4(sp) contains the address of dimension value
+			// The dimension value is the pointer to object
+			g_srcpos++;
+			check_obj_space(3);
+			g_object[g_objpos++]=0x8FA20004;          // lw    v0,4(sp)
+			g_object[g_objpos++]=0x8C420000;          // lw    v0,0(v0)
+			g_object[g_objpos++]=0x27BD0004;          // addiu sp,sp,4
+			return let_object_field();
+		}
+		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 if (b2=='.') {
+		// Field of object
+		g_srcpos++;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FC20000|(i*4);        // lw    v0,xx(s8)
+		return let_object_field();
+	} 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]==',');
+	// Renew sp stored in s5 stack.
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP; // sw          sp,-12(s5)
+	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 spos;
+	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++;
+		spos=g_srcpos;
+		err=get_label();
+		if (g_label && !err) {
+			if (search_var_name(g_label)!=-1) {
+				// This is a long var name.
+				g_label=0;
+				g_srcpos=spos;
+			}
+		}
+		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;
+}
+
+char* useclass_statement(){
+	char* err;
+	int i;
+	int* cmpdata;
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		// Check if the class already exists
+		cmpdata_reset();
+		while(cmpdata=cmpdata_find(CMPDATA_CLASS)){
+			if (cmpdata[1]==i) {
+				// The class was already defined.
+				i=0;
+				break;
+			}
+		}
+		if (i) {
+			// Remove a objects before USECLASS statement
+			g_objpos=0;
+			// Insert a NOP assembly. This will be replaced by jump statement.
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00000000; // nop
+			// Load new file to define class statement.
+			g_class=i;
+			return ERR_COMPILE_CLASS;
+		}
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+char* setdir_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_SETDIR);
+	return 0;
+}
+
+#ifdef __DEBUG
+	char* debug_statement(){
+		call_lib_code(LIB_DEBUG);
+		return 0;
+	}
+#endif
+
+// Aliases follow
+
+char* poke_statement(){
+	return poke_statement_sub(8);
+}
+
+char* poke16_statement(){
+	return poke_statement_sub(16);
+}
+
+char* poke32_statement(){
+	return poke_statement_sub(32);
+}
+
+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,
+	"POKE16 ",poke16_statement,
+	"POKE32 ",poke32_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,
+	"USECLASS ",useclass_statement,
+	"FIELD ",field_statement,
+	"METHOD ",method_statement,
+	"DELETE ",delete_statement,
+	"CALL ",call_statement,
+	"STATIC ",static_statement,
+	"SETDIR ",setdir_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;
+	// Allow shifting code object when stack is used.
+	// This will be disalloed when CMPDATA_UNSOLVED etc is used.
+	g_allow_shift_obj=1;
+	// 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;
+}

--- trunk/string.c	(revision 36)
+++ trunk/string.c	(revision 37)
@@ -6,6 +6,10 @@
 */
 
 /*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
   Public functions:
     char* get_string(void);
 	char* simple_string(void);
@@ -88,6 +92,21 @@
 			g_temp_area_used=1;
 			return 0;
 		}
+		if (g_source[g_srcpos]=='.') {
+			// This is an object field or method to return string
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+			g_srcpos++;
+			return string_obj_field();
+		} else if (g_source[g_srcpos]=='(') {
+			// An array element contains pointer to an object.
+			g_srcpos++;
+			err=get_dim_value(i);
+			if (err) return err;
+			if (g_source[g_srcpos]!='.') return ERR_SYNTAX;
+			g_srcpos++;
+			return string_obj_field();
+		}
 		if (g_source[g_srcpos]!='$') return ERR_SYNTAX;
 		g_srcpos++;
 		// String variable
@@ -194,7 +213,7 @@
 		prevpos=g_objpos;
 		// Stack decrement command will be filled later
 		check_obj_space(1);
-		g_objpos++;
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
 	}
 	err=get_string_sub();
 	if (err) return err;
@@ -201,8 +220,10 @@
 	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--;
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
 		} else {
 			// Stack was used.
 			check_obj_space(1);

--- trunk/value.c	(revision 36)
+++ trunk/value.c	(revision 37)
@@ -6,6 +6,10 @@
 */
 
 /*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
   Public function is only get_value().
 */
 
@@ -73,6 +77,13 @@
 		check_obj_space(1);
 		g_object[g_objpos++]=0x00021023; // subu v0,zero,v0
 		g_intconst=-g_intconst;
+	} else if (b1=='&') {
+		// '&' operator
+		g_srcpos++;
+		i=get_var_number();
+		if (i<0) return ERR_SYNTAX;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27C20000|(i*4); // addiu       v0,s8,xxxx
 	} else {
 		// Main routine of getting value here
 		if (b1=='+') g_srcpos++; // Ignore unary '+' operator
@@ -92,6 +103,9 @@
 				} else if ('A'<=b1 && b1<='F') {
 					i*=16;
 					i+=b1-'A'+0x0A;
+				} else if (b1==' ') { // Skip ' '
+					// Avoid "ELSE" statement etc
+					if ('F'<g_source[g_srcpos+2]) break;
 				} else {
 					break;
 				}
@@ -116,7 +130,7 @@
 				if ('0'<=b1 && b1<='9') {
 					i*=10;
 					i+=b1-'0';
-				} else {
+				} else if (b1!=' ') { // Skip ' '
 					break;
 				}
 				g_srcpos++;
@@ -123,7 +137,11 @@
 			}
 			// The next character should not be '.' or 'E'.
 			// Or, it must be recognized as a float value.
-			if (b1=='.' || b1=='E') return ERR_SYNTAX;
+			if (b1=='.') return ERR_SYNTAX;
+			if (b1=='E') {
+				b2=g_source[g_srcpos+1];
+				if (b2==' ' || '0'<=b2 && b2<='9') return ERR_SYNTAX;
+			}
 			g_intconst=i;
 			if (i&0xFFFF0000) {
 				// 32 bit
@@ -145,11 +163,19 @@
 			if (g_source[g_srcpos]=='(') {
 				// Dimension
 				g_srcpos++;
-				return get_dim_value(i);
+				err=get_dim_value(i);
+				if (err) return err;
+			} else {
+				// Simple value
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
 			}
-			// Simple value
-			check_obj_space(1);
-			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+			// Check if this is an object
+			if (g_source[g_srcpos]=='.') {
+				// This is an object. See the filed of it.
+				g_srcpos++;
+				return integer_obj_field();
+			}
 		}
 	}
 	// No error 
@@ -206,7 +232,7 @@
 		prevpos=g_objpos;
 		// Stack decrement command will be filled later
 		check_obj_space(1);
-		g_objpos++;
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
 	}
 	err=get_value_sub(priority(OP_VOID));
 	if (err) return err;
@@ -213,8 +239,10 @@
 	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--;
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
 		} else {
 			// Stack was used.
 			check_obj_space(1);

--- trunk/varname.c	(revision 36)
+++ trunk/varname.c	(revision 37)
@@ -5,6 +5,10 @@
    [e-mail]
 */
 
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
 #include "compiler.h"
 
 /*
@@ -14,106 +18,117 @@
 */
 
 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
+	0x000106b8, /*ABS*/
+	0x0001f67c, /*ACOS*/
+	0x0002414c, /*ARGS*/
+	0x0001090c, /*ASC*/
+	0x0002469f, /*ASIN*/
+	0x00024a8f, /*ATAN*/
+	0x002f7c1e, /*ATAN2*/
+	0x0047c31c, /*BREAK*/
+	0x00035869, /*CALL*/
+	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*/
+	0x0fe19c42, /*DELETE*/
+	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*/
+	0x00a7e061, /*FIELD*/
+	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*/
+	0x1ab733b3, /*GETDIR*/
+	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*/
+	0x000148f8, /*NEW*/
+	0x00014a5d, /*NOT*/
+	0x000152c0, /*PCG*/
+	0x000cacec, /*PEEK*/
+	0x3b1c6aea, /*PEEK16*/
+	0x3b1c6b2e, /*PEEK32*/
+	0x00010252, /*PI*/
+	0x01ac8479, /*POINT*/
+	0x000ce05e, /*POKE*/
+	0x3c20dc0a, /*POKE16*/
+	0x3c20dc4e, /*POKE32*/
+	0x00015480, /*POW*/
+	0x01aea739, /*PRINT*/
+	0x000cf3d5, /*PSET*/
+	0x3cb45fa4, /*PUBLIC*/
+	0x3cc0fe21, /*PUTBMP*/
+	0x000e18d5, /*READ*/
+	0x00015d2e, /*REM*/
+	0x425c9703, /*RETURN*/
+	0x00015e69, /*RND*/
+	0x45c26d49, /*SCROLL*/
+	0x45f6e3b3, /*SETDIR*/
+	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
 };
@@ -180,16 +195,41 @@
 */
 
 int get_var_number(){
-	int i;
+	int i,j,spos;
+	int* record;
 	// This must be a short or long var name.
+	spos=g_srcpos;
 	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;
+	// Check if CLASS::STATIC
+	if (g_source[g_srcpos]==':' && g_source[g_srcpos+1]==':') {
+		// This is CLASS::STATIC
+		g_srcpos++;
+		g_srcpos++;
+		j=check_var_name();
+		if (j<26) return -1;
+		cmpdata_reset();
+		while(record=cmpdata_find(CMPDATA_STATIC)){
+			if (record[1]!=i) continue;
+			if (record[2]!=j) continue;
+			// Found CLASS::STATIC
+			i=record[0]&0x0000FFFF;
+			j=0;
+			break;
+		}	
+		if (j) {
+			// Not found. Maybe a static method
+			g_srcpos=spos;
+			return -1;
+		}
+	} else {
+		// 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;