#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <mes2.h>
#define MAX_BUF	200
#define MAX_ARG	128
#define MAX_HISTORY 20
#define NONE	0
#define COMMAND	1
#define SYNTAX	2
#define IOERR	3
#define DSKFULL	4
#define CMDFULL	5
#define NOFILE	6
#define MEMFULL	7
#define IGFMT	8
#define ARIGN	9
#define FSCHK	2
static char	prompt[16], echo_flag, history_flag;
static char	cmd_buf[MAX_BUF], *cmd_argv[MAX_ARG], tmp_buf[80];
static int	tftp_timeout, retvalue;
static int	values[32];
static char	*histories;
static int	max_history, cur_history;
static int	shell(int, char*);

typedef struct {
	int		(*function)(int, char**);
	unsigned char	command[12];
	unsigned char	min, max, opt;
} function_table;

static function_table table[] = {
	{0,"dump",	2, 3, NONE},
	{0,"setdata",	3, 4, NONE},
	{0,"dir",	1, 2, NONE},
	{0,"zeromem",	3, 3, NONE},
	{0,"ifconfig",	1, 4, NONE},
	{0,"gateway",	2, 2, NONE},
	{0,"ping",	2, 4, NONE},
	{0,"echo",	2, 2, NONE},
	{0,"del",	2, 2, NONE},
	{0,"ssid",	3, 4, NONE},
	{0,"wipm",	3, 3, NONE},
	{0,"tftp",	3, 4, NONE},
	{0,"type",	2, 2, NONE},
	{0,"pwd",	1, 1, NONE},
	{0,"cd",	2, 2, NONE},
	{0,"mount",	2, 2, NONE},
	{0,"eject",	2, 2, NONE},
	{0,"format",	2, 2, NONE},
	{0,"copy",	3, 3, NONE},
	{0,"dns",	2, 2, NONE},
	{0,"wep",	1, 6, NONE},
	{0,"wait",	2, 2, NONE},
	{0,"getssid",	2, 2, NONE},
	{0,"tftptime",	2, 2, NONE},
	{0,"ps",	1, 2, NONE},
	{0,"kill",	2, 2, NONE},
	{0,"df",	1, 1, NONE},
	{0,"sleep",	2, 2, NONE},
	{0,"regist",	2, 4, NONE},
	{0,"turbo",	2, 2, NONE},
	{0,"history",	2, 2, NONE},
	{0,"",		1, MAX_ARG, NONE}
};

static int read_line(int fd, char* buffer, char** argv) {
	unsigned int	argc, n;
	int		i, p;
	unsigned char	c, cbuf[3], *ptr;

	p = 0;
	bzero(buffer, MAX_BUF);
	cur_history = 0;
	for(;;) {
		bzero(cbuf, 3);
		do {
			if(fd == 0) {
				sleep(1);
				n = read(0, cbuf, 3);
				sleep(1);
				c = cbuf[0];
			} else {
				n = read(fd, &c, 1);
				if(n == 0) return -1;
			}
		} while(n == 0);
		if(n == 3 && cbuf[0] == 0x1b && cbuf[1] == 0x5b && (cbuf[2] == 0x41 || cbuf[2] == 0x42)) {
			if(cbuf[2] == 0x41) {
				if(cur_history > (max_history - 1)) continue;
			}
			if(cbuf[2] == 0x42) {
				if(cur_history <= 0) continue;
				cur_history --;
			}
			ptr = &histories[cur_history * MAX_BUF];
			if(ptr[0] != 0) {
				strcpy(buffer, ptr);
				if(echo_flag) {
					printf("\033[80D\033[2K%s%s", prompt, buffer);
					p = strlen(buffer);
				}
			}
			if(cbuf[2] == 0x41) {
				cur_history++;
			}
			continue;
		}
		if(c >= 0x80) continue;
		if(c == '\n') break;
		if(c == '\r') break;
		if(c == 0x7f) c = 8;
		if(c == 8) {
			if(p > 0) {
				if(echo_flag) {
					putchar(8);
					putchar(' ');
					putchar(8);
				}
				p--;
			}
		} else {
			if(p <= (MAX_BUF - 2)) {
				if(echo_flag) putchar(c);
				buffer[p++] = c;
			}
		}
	}
	buffer[p] = 0;
	if(buffer[0] == 0) {
		if(echo_flag) putchar('\r');
		return 0;
	}
	if(fd == 0 && max_history > 0) {
		for(i = max_history - 2;i >= 0;i--) {
			strcpy(&histories[(i + 1) * MAX_BUF], &histories[i * MAX_BUF]);
		}
		strcpy(histories, buffer);
	}
	i = argc = 0;
	argv[argc++] = &(buffer[i]);
	while(buffer[i] != 0) {
		if(buffer[i] == ' ') {
			buffer[i] = 0;
			if(argc >= (MAX_ARG - 1)) break;
			argv[argc++] = &(buffer[i + 1]);
		}
		i++;
	}
	argv[argc] = 0;
	return argc;
}

static void err_message(int id) {
	static const char message[10][20] = {
		"Command not found.",
		"Syntax error.",
		"Disk I/O error.",
		"Disk is full.",
		"Buffer is full.",
		"File not found.",
		"Memory is full.",
		"Ignore file format.",
		"Arignment error.",
		"Unknown error."
	};
	int	i;

	i = (id > 9) ? 9 : id - 1;
	if(echo_flag) printf("ERROR[%s]\r", message[i]);
	retvalue = -1;
}

static int dump(int argc, char** argv) {
	int	  i, n, num;
	char		  *pb;
	short		  *pw;

	sscanf(argv[argc - 1], "%x", &num);
	n = num + 16 * 8;
	while(num < n) {
		printf("%08x : ", num);
		if(argc == 3 && argv[1][0] == 'w') {
			if(num & 1) return ARIGN;
			pw = (short*)num;
			for(i = 0;i < 8;i++) {
				if(i == 4) printf("  ");
				printf("%04x", (int)(*pw++) & 0xffff);
			}
		} else {
			pb = (char*)num;
			for(i = 0;i < 16;i++) {
				if(i == 8) printf("  ");
				printf("%02x", (int)(*pb++) & 0xff);
			}
		}
		putchar('\r');
		num += 16;
	}
	return NONE;
}

static int execution(int argc, char** argv) {
	int	pid, waitflag;

	waitflag = 1;
	if(argv[argc - 1][0] == '&' && argv[argc - 1][1] == 0) {
		waitflag = 0;
		argv[--argc] = 0;
	}
	pid = exec(argc, argv);
	if(pid == -1) return NOFILE;
	if(waitflag == 1) {
		wait(pid);
		retvalue = ret_value();
	}
	return NONE;
}

static int set_data(int argc, char** argv) {
	int	num, data;
	char	*addrchar;
	short	*addrword;

	sscanf(argv[argc - 2], "%x", &data);
	addrchar = (char*)data;
	if(argc == 4 && argv[1][0] == 'w' && data & 1) return ARIGN; 
	addrword = (short*)data;
	sscanf(argv[argc - 1], "%x", &num);
	if(addrchar == (char*)-1 || num == -1) return SYNTAX;
	if(argc == 4 && argv[1][0] == 'w') addrword[0] = num;
	else addrchar[0] = num;
	printf(" updated.\r");
	return NONE;
}

static int clear_memory(int argc, char** argv) {
	int	num, data;
	char*	addr;

	sscanf(argv[1], "%x", &data);
	addr = (char*)data;
	sscanf(argv[2], "%x", &num);
	if(addr == (char*)-1 || num == -1) return SYNTAX;
	bzero(addr, num);
	printf(" cleared.\r");
	return NONE;
}

static int dir(int argc, char** argv) {
	int	fd;
	DirEnt	ent;

	fd = SetDirent((argc == 1) ? "" : argv[1], &ent);
	if(fd == -1) return NOFILE;
	while(NextRecord(fd, &ent) == 0) {
		if(ent.attr & 0x10) {
			printf("[%-10s]\r", ent.name);
		} else {
			printf("%-10s\t%5d[char]\r", ent.name, ent.length);
		}
	}
	close(fd);
	return NONE;
}

static int remove(int argc, char** argv) {
	if(DeleteFile(argv[1]) == -1) return NOFILE;
	return NONE;
}

static int ssid(int argc, char** argv) {
	int	i, fd, dat, net, ret;
	char	str[36], tmp[3];

	net = 0;
	fd = open(argv[1], -1);
	if(fd == -1) {
		net = get_netnum(argv[1]);
		if(net == -1) {
			return IOERR;
		}
	}
	switch(argc) {
	case 3:
		str[34] = 0;
		strncpy(str, argv[2], 34);
		break;
	case 4:
		if(argv[2][0] != 'x') return SYNTAX;
		tmp[2] = 0;
		for(i = 0;i < 34;i++) {
			if(argv[2][i * 2] == 0 || argv[2][i * 2 + 1] == 0) break;
			tmp[0] = argv[2][i * 2];
			tmp[1] = argv[2][i * 2 + 1];
			sscanf(tmp, "%x", &dat);
			str[i] = dat;
		}
		str[i] = 0;
		break;
	default:
		return SYNTAX;
	}
	if(fd == -1) {
		ret = net_ioctl(net, (int)str, WI_SETSSID);
	} else {
		ret = ioctl(fd, (int)str, WI_SETSSID);
		close(fd);
	}
	return (ret == -1) ? IOERR : NONE;
}

static int wi_pm(int argc, char** argv) {
	int	flag, fd, ret, net;
	int	ip, mask;
	char	buf[6];

	if(argv[2][0] != 'o') return SYNTAX;
	switch(argv[2][1]) {
	case 'n':
		flag = 1;
		break;
	case 'f':
		flag = 0;
		break;
	default:
		return SYNTAX;
	}
	fd = open(argv[1], -1);
	if(fd == -1) {
		net = get_netnum(argv[1]);
		if(net == -1) return IOERR;
		ret = get_ipinfo(net, &ip, &mask, buf);
		if(ret == -1) return IOERR;
		ifdown(net);
		fd = open(argv[1], -1);
		if(fd == -1) return IOERR;
		ret = ioctl(fd, flag, WI_PMGTON);
		close(fd);
		ifconfig(argv[1], ip, mask);
	} else {
		ret = ioctl(fd, flag, WI_PMGTON);
		close(fd);
	}
	return (ret == -1) ? IOERR : NONE;
}

static void if_info(int num) {
	int	i, ip, mask, n, ret;
	char	buf[6];

	ret = get_ipinfo(num, &ip, &mask, buf);
	if(ret == -1) return;
	printf("net%d\tIP Address:", num);
	for(i = 0;i < 4;i++) {
		n = (ip >> ((3 - i) * 8)) & 0xff;
		printf("%d.", n);
	}
	printf(" Netmask:");
	for(i = 0;i < 4;i++) {
		n = (mask >> ((3 - i) * 8)) & 0xff;
		printf("%d.", n);
	}
	printf(" MAC:");
	for(i = 0;i < 5;i++) printf("%02x:", (int)buf[i] & 0xff);
	printf("%02x\r\r", (int)buf[i] & 0xff);
}

static int if_config(int argc, char** argv) {
	int	i, ip, mask, n, ret, net;

	if(argc == 2) return SYNTAX;
	if(argc == 1 && echo_flag) {
		for(i = 0;i < 4;i++) if_info(i);
		return NONE;
	}
	if(memcmp(argv[2], "down", 4) == 0) {
		sscanf(argv[1], "%d", &net);
		n = ifdown(net);
		if(n == -1) return IOERR;
		return NONE;
	}
	ip = strtoip(argv[2], &ret);
	if(ret == -1) return SYNTAX;
	if(argc == 4) {
		mask = strtoip(argv[3], &ret);
		if(ret == -1) return SYNTAX;
	} else {
		mask = IPADDR(255,255,255,0);
	}
	n = ifconfig(argv[1], ip, mask);
	if(n == -1) return IOERR;
	if(echo_flag) if_info(n);
	return NONE;
}

static int gateway(int argc, char** argv) {
	int	ip;

	ip = gethostbyname(argv[1]);
	if(ip == 0) return SYNTAX;
	set_gateway(ip);
	return NONE;
}

static int set_dns(int argc, char** argv) {
	int	ip, ret;

	ip = strtoip(argv[1], &ret);
	if(ret == -1) return SYNTAX;
	dns_server(ip);
	return NONE;
}

static void tftp_message() {
	putchar('.');
}

static int tftp(int argc, char** argv) {
	int	ip;
	char	*name;

	if(argc == 4 && argv[1][0] != '-') return SYNTAX;
	ip = gethostbyname(argv[2]);
	if(ip == 0) return IOERR;
	if(argc == 3) {
		name = strrchr(argv[1], '/');
		if(name == 0) name = argv[1];
		if(tftp_load(ip, name, tftp_message, tftp_timeout) == -1) return IOERR;
	} else {
		name = strrchr(argv[3], '/');
		if(name == 0) name = argv[3];
		if(tftp_save(ip, name, tftp_message, tftp_timeout) == -1) return IOERR;
	}
	return NONE;
}

static int set_tftp_timeout(int argc, char** argv) {
	sscanf(argv[1], "%d", &tftp_timeout);
	printf("Timeout of tftp is %d[sec].\r", tftp_timeout);
	return NONE;
}

static int _ping(int argc, char** argv) {
	int		i, size, times;
	unsigned int	ip;

	size = 32;
	times = 4;
	ip = gethostbyname(argv[1]);
	if(ip == 0) return SYNTAX;
	for(i = 2;i < argc;i++) {
		switch(argv[i][0]) {
		case 'N':
		case 'n':
			sscanf(&argv[i][1], "%d", &times);
			break;
		case 'S':
		case 's':
			sscanf(&argv[i][1], "%d", &size);
//			if(size > 1420) return SYNTAX;
			break;
		default:
			return SYNTAX;
		}
	}
	printf("Pinging %s", argv[1]);
//	if(ret == -1) {
//		printf("(%d.", ip >> 24);
//		printf("%d.", (ip >> 16) & 0xff);
//		printf("%d.", (ip >> 8) & 0xff);
//		printf("%d)", ip & 0xff);
//	}
	printf(" of data.\r");
	for(i = 0;i < times;i++) {
		int	ret;
		
		ret = ping(ip,size);
		if(ret == -1) {
			printf("Request timed out.\r");
		} else {
			printf("Reply from %s:\r", argv[1]);
			sleep(1000);
		}
	}
	return NONE;
}

static int echo(int argc, char** argv) {
	if(strcmp(argv[1], "off") == 0) echo_flag = 0;
	else if(strcmp(argv[1], "on") == 0) echo_flag = 1;
	else return SYNTAX;
	return NONE;
}

static int type(int argc, char** argv) {
	int	fd, n;
	char	c;

	fd = open(argv[1], OptRead);
	if(fd == -1) return IOERR;
	n = read(fd, &c, 1);
	while(n > 0) {
		if(c != '\n') putchar(c);
		n = read(fd, &c, 1);
	}
	close(fd);
	return NONE;
}

#define	COPYBLKSIZ	512

static int copy(int argc, char** argv) {
	int	fdin, fdout, n, c;
	char	*buf;

	buf = malloc(COPYBLKSIZ);
	if(buf == 0) return MEMFULL;
	fdin = open(argv[1], OptRead);
	if(fdin == -1) {
		free(buf);
		return IOERR;
	}
	fdout = open(argv[2], OptWrite);
	if(fdout == -1) {
		close(fdin);
		free(buf);
		return IOERR;
	}
	c = 0;
	do {
		n = read(fdin, buf, COPYBLKSIZ);
		write(fdout, buf, n);
		if(++c > 16) {
			putchar('.');
			c = 0;
		}
	} while(n == COPYBLKSIZ);
	close(fdin);
	close(fdout);
	free(buf);
	return NONE;
}

static int pwd(int argc, char** argv) {
	printf("[%s]\r", cwd());
	return NONE;
}

static int _cd(int argc, char** argv) {
	if(cd(argv[1]) == -1) return NOFILE;
	return NONE;
}

static int _mount(int argc, char** argv) {
	int	chip;

	if(memcmp(argv[1], "usb", 3) == 0) {
		if(isdigit(argv[1][3])) {
			chip = argv[1][3] - '0';
			if(usb_mount(chip) == -1) return IOERR;
		}
	} else if(mount(argv[1]) == -1) {
		return IOERR;
	}
	return NONE;
}

static int _eject(int argc, char** argv) {
	int	chip;

	if(memcmp(argv[1], "usb", 3) == 0) {
		if(isdigit(argv[1][3])) {
			chip = argv[1][3] - '0';
			if(usb_eject(chip) == -1) return IOERR;
		}
	} else if(eject(argv[1]) == -1) {
		return IOERR;
	}
	return NONE;
}

static int _format(int argc, char** argv) {
	if(format(argv[1]) == -1) return IOERR;
	return NONE;
}

static int _wait(int argc, char** argv) {
	int	tim;

	sscanf(argv[1], "%d", &tim);
	sleep(tim * 100);
	return NONE;
}

static int wep(int argc, char **argv) {
	int	i, key, fd, kind, ret, dat;
	char	str[14], tmp[3];

	fd = open(argv[1], -1);
	if(fd == -1) {
		printf("Usage: wep dev 64/128 1-4 string\r");
		printf("Usage: wep dev 64/128 1-4 x hexstring\r");
		printf("       wep dev\r");
		return NONE;
	}
	if(argc == 2) {
		ioctl(fd, NOWEP, WI_WEPON);
		close(fd);
		return NONE;
	}
	switch(argc) {
	case 5:
		str[13] = 0;
		strncpy(str, argv[4], 13);
		break;
	case 6:
		if(argv[4][0] != 'x') {
			close(fd);
			return SYNTAX;
		}
		tmp[2] = 0;
		for(i = 0;i < 13;i++) {
			if(argv[5][i * 2] == 0 || argv[5][i * 2 + 1] == 0) break;
			tmp[0] = argv[5][i * 2];
			tmp[1] = argv[5][i * 2 + 1];
			sscanf(tmp, "%x", &dat);
			str[i] = dat;
		}
		str[i] = 0;
		break;
	default:
		close(fd);
		return SYNTAX;
	}
	sscanf(argv[3], "%d", &key);
	ret = ioctl(fd, key, WI_SETWEPKEY);
	if(ret == -1) {
		close(fd);
		return IOERR;
	}
	switch(argv[2][0]) {
	case '6':
		kind = WEP64;
		ret = ioctl(fd, (int)str, WI_SETWEP64);
		break;
	case '1':
		kind = WEP128;
		ret = ioctl(fd, (int)str, WI_SETWEP128);
		break;
	default:
		printf("Paramater error.\r");
		close(fd);
		return SYNTAX;
	}
	if(ret != -1) ret = ioctl(fd, kind, WI_WEPON);
	close(fd);
	return (ret != -1) ? NONE : IOERR;
}

static int ps(int argc, char **argv) {
	int		pid, ret, ac;
	char		c, **av;
	struct process	info;

	for(pid = 1;;pid++) {
		ret = ps_info(pid, &info);
		if(ret == -1) break;
		if(ret == 0) continue;
		c = (info.flag & PS_WAIT) ? 'S' : 'R';
		av = info.argv;
		printf("pid:%d ", pid);
		printf("base:%x ", info.address);
		if(argc == 2 && argv[1][0] == 'x') {
			printf("pc:%x ", info.pc);
			printf("sp:%x ", info.stack);
			printf("tcb:%x ", info.tcb);
		}
		putchar(c);putchar(' ');
		for(ac = 0;;ac++) {
			if(av[ac] == 0) break;
			printf("%s ", av[ac]);
		}
		putchar('\r');
	}
	return NONE;
}

static int _kill(int argc, char **argv) {
	int	pid;

	sscanf(argv[1], "%d", &pid);
	return (kill(pid) != -1) ? NONE : IOERR;
}

static int _sleep(int argc, char **argv) {
	int	ms;

	sscanf(argv[1], "%d", &ms);
	sleep(ms);
	return NONE;
}

static int regist(int argc, char** argv) {
	int	i, n, ret, d;
	char	flag, name[9];

	if(argv[1][0] == '-' && argv[1][1] == 's') {
		if(argc != 4) return SYNTAX;
		flag = 0;
		n = strlen(argv[3]);
		for(i = 0;i < n;i++) {
			if(!isdigit(argv[3][i])) {
				flag = 1;
				break;
			}
		}
		if(flag == 1) {
			set_regist_string(argv[2], argv[3]);
		} else {
			n = stoi(argv[3]);
			set_regist_data(argv[2], n);
		}
	} else {
		if(argc != 2) return SYNTAX;
		if(argv[1][0] == '-' && argv[1][1] == 'l') {
			for(i = 0;;i++) {
				ret = list_regist_string(i, name);
				if(ret == -1) break;
				if(ret != 0) {
					get_regist_string(name, tmp_buf, 79);
					printf(" %s [string value]\t%s\r", name, tmp_buf);
				} else {
					ret = list_regist_data(i, name);
					if(ret != 0) {
						get_regist_data(name, &d);
						printf(" %s [fixed value]\t%d\r", name, d);
					}
				}
			}
		} else {
			ret = get_regist_string(argv[1], tmp_buf, 79);
			if(ret != -1) {
				printf("%s\r", tmp_buf);
				return NONE;
			} else {
				ret = get_regist_data(argv[1], &d);
				if(ret != -1) {
					printf("%d\r", d);
					return NONE;
				}
			}
			return IOERR;
		}
	}
	return NONE;
}

static int df(int argc, char **argv) {
	int	ret, disk, total, count, n;
	char	name[16];

	for(disk = 0;;disk++) {	
		ret = fat_status(disk, &total, &count, name);
		if(ret == -1) break;
		if(total > 0) {
			printf("%s\t", name);
			printf("Total %d[byte]\t", total * 512);
			n = (total - count) * 512;
			printf("Used %d[byte]\t", n);
			if(n < 10000) printf("\t");
			printf("%d%% free.\r", (count * 100) / total);
		}
	}
	return NONE;
}

static int get_ssid(int argc, char **argv) {
	int	net, ret;
	char	name[34];

	net = get_netnum(argv[1]);
	if(net == -1) return IOERR;
	bzero(name, 34);
	ret = net_ioctl(net, (int)name, WI_GETSSID);
	if(ret != -1) {
		printf("SSID[%s]\r", name);
	} else {
		printf("ioctl error\r");
		return IOERR;
	}
	return NONE;
}

static int turbo(int argc, char **argv) {
	if(strcmp(argv[1], "on") == 0) {
		hw_config(HW_CONFIG_TURBO, 1, 0);
		return NONE;
	} else if(strcmp(argv[1], "off") == 0) {
		hw_config(HW_CONFIG_TURBO, 0, 0);
		return NONE;
	}
	return NONE;
}

static int history(int argc, char **argv) {
	if(strcmp(argv[1], "on") == 0) {
		history_flag = 1;
		return NONE;
	} else if(strcmp(argv[1], "off") == 0) {
		history_flag = 0;
		return NONE;
	}
	return NONE;
}

#define OTHER_DATA	1
#define VALUE_DATA	2
#define CONST_DATA	3

#define EXIT_CMD	1
#define GOTO_CMD	2

static int cmd_line(int argc, char **argv) {
	int	ret, i, fd;
	char	*ext;

	if(strcmp(argv[0], "Exit") == 0) return EXIT_CMD;
	if(strcmp(argv[0], "Goto") == 0) return GOTO_CMD;
	ext = strchr(argv[0], '.');
	if(ext != 0 && strcmp(ext, ".bat") == 0) {
		char	name[64];

		name[63] = 0;
		strncpy(name, argv[0], 63);
		fd = open(name, OptRead);
		if(fd == -1) {
			err_message(NOFILE);
		} else {
			fd = shell(fd, name);
			close(fd);
		}
	} else {
		retvalue = 0;
		for(i = 0;;i++) {
			if(strcmp(argv[0], table[i].command) == 0 || table[i].command[0] == 0) {
				if(argc >= table[i].min && argc <= table[i].max) {
					ret = (*(table[i].function))(argc, argv);
					if(ret > NONE) err_message(ret);
				} else {
					err_message(SYNTAX);
				}
				break;
			}
			if(table[i].command[0] == 0) break;
		}
	}
	return 0;
}

static int get_value(char *arg, int *data, int op) {
	int	i, n, flag;

	n = strlen(arg);
	flag = 1;
	i = 0;
	if(arg[0] == '-') i++;
	for(;i < n;i++) {
		if(!isdigit(arg[i])) {
			flag = 0;
			break;
		}
	}
	if(n == 1 && arg[0] >= 'A' && arg[0] <= 'Z') {
		n = 'A' - arg[0];
		if(op == 0) {
			*data = values[n];
		} else {
			values[n] = *data;
		}
		return VALUE_DATA;
	} else if(flag == 1) {
		*data = atoi(arg);
		return CONST_DATA;
	}
	return OTHER_DATA;
}

static int shell(int fd, char *name) {
	int	i, n, argc, data, data2, status, argoff;
	char	echo_save, label[16];

	for(i = 0;i < 32;i++) values[i] = 0;
	strcpy(prompt, "MES >");
	for(;;) {
		if(fd == 0) printf(prompt);
		argc = read_line(fd, cmd_buf, cmd_argv);
		if(fd != 0 && argc == -1) return fd;
		if(argc < 1) continue;
		if(echo_flag) putchar('\r');
		if(argc >= MAX_ARG) {
			err_message(CMDFULL);
			continue;
		}
		status = 0;
		n = strlen(cmd_argv[0]);
		if(cmd_argv[0][n - 1] == ':') continue;
		if(strcmp(cmd_argv[0], "Loop") == 0) {
			for(;;) cmd_line(argc - 1, &cmd_argv[1]);
		} else if(argc > 2 && get_value(cmd_argv[0], &data, 0) == VALUE_DATA && strcmp(cmd_argv[1], "=") == 0) {
			if(get_value(cmd_argv[2], &data, 0) != OTHER_DATA) {
				get_value(cmd_argv[0], &data, 1);
			} else {
				argoff = 2;
				status = cmd_line(argc - 2, &cmd_argv[2]);
				data = retvalue;
				get_value(cmd_argv[0], &data, 1);
			}
		} else if(argc == 2 && get_value(cmd_argv[1], &data, 0) != OTHER_DATA && strcmp(cmd_argv[0], "Print") == 0) {
			printf("%d\r", data);
		} else if(argc > 4 && get_value(cmd_argv[1], &data, 0) != OTHER_DATA && get_value(cmd_argv[3], &data2, 0) != OTHER_DATA && strcmp(cmd_argv[0], "If") == 0) {
			argoff = 4;
			switch(cmd_argv[2][0]) {
			case '=':
				if(data == data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '!':
				if(data != data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '>':
				if(data > data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '<':
				if(data < data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			default:
				err_message(SYNTAX);
			}
		} else {
			argoff = 0;
			status = cmd_line(argc, &cmd_argv[0]);
		}
		switch(status) {
		case EXIT_CMD:
			return fd;
		case GOTO_CMD:
			if(fd == 0 || argc != (argoff + 2)) {
				err_message(SYNTAX);
				break;
			}
			label[14] = 0;
			strncpy(label, cmd_argv[argoff + 1], 14);
			strcat(label, ":");
			close(fd);
			fd = open(name, OptRead);
			for(;;) {
				echo_save = echo_flag;
				echo_flag = 0;
				argc = read_line(fd, cmd_buf, cmd_argv);
				echo_flag = echo_save;
				if(fd != 0 && argc == -1) {
					err_message(SYNTAX);
					return fd;
				}
				if(strcmp(cmd_argv[0], label) == 0) break;
			}
			break;
		}
	}
	return fd;
}

static void autoexec() {
	int	fd;

	fd = open("autoexec.bat", OptRead);
	if(fd == -1) return;
	fd = shell(fd, "autoexec.bat");
	close(fd);
}

int main() {
	int	version, rev;

	table[0].function = dump;
	table[1].function = set_data;
	table[2].function = dir;
	table[3].function = clear_memory;
	table[4].function = if_config;
	table[5].function = gateway;
	table[6].function = _ping;
	table[7].function = echo;
	table[8].function = remove;
	table[9].function = ssid;
	table[10].function = wi_pm;
	table[11].function = tftp;
	table[12].function = type;
	table[13].function = pwd;
	table[14].function = _cd;
	table[15].function = _mount;
	table[16].function = _eject;
	table[17].function = _format;
	table[18].function = copy;
	table[19].function = set_dns;
	table[20].function = wep;
	table[21].function = _wait;
	table[22].function = get_ssid;
	table[23].function = set_tftp_timeout;
	table[24].function = ps;
	table[25].function = _kill;
	table[26].function = df;
	table[27].function = _sleep;
	table[28].function = regist;
	table[29].function = turbo;
	table[30].function = history;
	table[31].function = execution;
	echo_flag = 1;
	history_flag = 0;
	tftp_timeout = 10;
	version = mesver();
	rev = version & 0xff;
	version >>= 8;
	histories = malloc(MAX_HISTORY * MAX_BUF);
	max_history = (histories == 0) ? 0 : MAX_HISTORY;
	if(max_history > 0) bzero(histories, max_history * MAX_BUF);
	printf("\033[;H\033[2J\033[%d;%dH",10,1);
	printf("\t\t    +------------------------------------+\r");
	if(rev < 128) {
		printf("\t\t    | Micro Embeded System Ver%d.%d Rev%02d  |\r", (version >> 8) & 0xff, version & 0xff, rev);
	} else {
		rev = 256 - rev;
		printf("\t\t    | Micro Embeded System Ver%d.%d beta%02d |\r", (version >> 8) & 0xff, version & 0xff, rev);
	}
	printf("\t\t    +------------------------------------+\r");
	printf("\033[%d;%dH",24,1);
	autoexec();
	shell(0, 0);
	if(max_history > 0) free(histories);
	return 0;
}