source: EcnlProtoTool/trunk/prototool/src/shellif.c@ 286

/*
 *  TOPPERS ECHONET Lite Communication Middleware
 * 
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 * 
 *  ã‹L’˜ìŒ ŽÒ‚́CˆÈ‰º‚Ì(1)`(4)‚ÌðŒ‚ð–ž‚½‚·ê‡‚ÉŒÀ‚èC–{ƒ\ƒtƒgƒEƒF
 *  ƒAi–{ƒ\ƒtƒgƒEƒFƒA‚ð‰ü•Ï‚µ‚½‚à‚Ì‚ðŠÜ‚ށDˆÈ‰º“¯‚¶j‚ðŽg—pE•¡»E‰ü
 *  •ÏEÄ”z•ziˆÈ‰ºC—˜—p‚ƌĂԁj‚·‚邱‚Ƃ𖳏ž‚Å‹–‘ø‚·‚éD
 *  (1) –{ƒ\ƒtƒgƒEƒFƒA‚ðƒ\[ƒXƒR[ƒh‚ÌŒ`‚Å—˜—p‚·‚éê‡‚ɂ́Cã‹L‚Ì’˜ì
 *      Œ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’肪C‚»‚Ì‚Ü‚Ü‚ÌŒ`‚Ń\[
 *      ƒXƒR[ƒh’†‚ÉŠÜ‚Ü‚ê‚Ä‚¢‚邱‚ƁD
 *  (2) –{ƒ\ƒtƒgƒEƒFƒA‚ðCƒ‰ƒCƒuƒ‰ƒŠŒ`Ž®‚ȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
 *      —p‚Å‚«‚éŒ`‚ōĔz•z‚·‚éê‡‚ɂ́CÄ”z•z‚É”º‚¤ƒhƒLƒ…
ƒƒ“ƒgi—˜—p
 *      ŽÒƒ}ƒjƒ…
ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L
 *      ‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
 *  (3) –{ƒ\ƒtƒgƒEƒFƒA‚ðC‹@Ší‚É‘g‚ݍž‚ނȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
 *      —p‚Å‚«‚È‚¢Œ`‚ōĔz•z‚·‚éê‡‚ɂ́CŽŸ‚Ì‚¢‚¸‚ê‚©‚ÌðŒ‚ð–ž‚½‚·‚±
 *      ‚ƁD
 *    (a) Ä”z•z‚É”º‚¤ƒhƒLƒ…
ƒƒ“ƒgi—˜—pŽÒƒ}ƒjƒ…
ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜
 *        ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
 *    (b) Ä”z•z‚ÌŒ`‘Ô‚ðC•Ê‚É’è‚ß‚é•û–@‚É‚æ‚Á‚āCTOPPERSƒvƒƒWƒFƒNƒg‚É
 *        •ñ‚·‚邱‚ƁD
 *  (4) –{ƒ\ƒtƒgƒEƒFƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚é‚¢‚©‚Ȃ鑹
 *      ŠQ‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð–Ɛӂ·‚邱‚ƁD
 *      ‚Ü‚½C–{ƒ\ƒtƒgƒEƒFƒA‚̃†[ƒU‚Ü‚½‚̓Gƒ“ƒhƒ†[ƒU‚©‚ç‚Ì‚¢‚©‚Ȃ闝
 *      —R‚ÉŠî‚­¿‹‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð
 *      –Ɛӂ·‚邱‚ƁD
 * 
 *  –{ƒ\ƒtƒgƒEƒFƒA‚́C–³•ÛØ‚Å’ñ‹Ÿ‚³‚ê‚Ä‚¢‚é‚à‚Ì‚Å‚ ‚éDã‹L’˜ìŒ ŽÒ‚¨
 *  ‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚́C–{ƒ\ƒtƒgƒEƒFƒA‚ÉŠÖ‚µ‚āC“Á’è‚ÌŽg—p–Ú“I
 *  ‚ɑ΂·‚é“K‡«‚àŠÜ‚߂āC‚¢‚©‚È‚é•ÛØ‚às‚í‚È‚¢D‚Ü‚½C–{ƒ\ƒtƒgƒEƒF
 *  ƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚½‚¢‚©‚Ȃ鑹ŠQ‚ÉŠÖ‚µ‚Ä‚àC‚»
 *  ‚̐ӔC‚𕉂í‚È‚¢D
 * 
 *  @(#) $Id: shellif.c 286 2017-05-02 15:25:33Z coas-nagasima $
 */
#include <setjmp.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
#include <poll.h>
#include <stdarg.h>
#include "shellif.h"
#include "analogin_api.h"
#include "gpio_api.h"
#include "i2c_api.h"
#include "pwmout_api.h"
#include "rtc_api.h"
#include "serial_api.h"
#include "us_ticker_api.h"
#include "wait_api.h"
#include "arduino.h"
#include "usrcmd.h"
#include <sys/mman.h>
#include <signal.h>

typedef struct __dirstream DIR;

typedef void (*analogin_init_t)(analogin_t *obj, PinName pin);
typedef uint16_t (*analogin_read_u16_t)(analogin_t *obj);
typedef void (*gpio_init_t)(gpio_t *obj, PinName pin);
typedef void (*gpio_dir_t)(gpio_t *obj, PinDirection direction);
typedef int (*i2c_start_t)(i2c_t *obj);
typedef int (*i2c_stop_t)(i2c_t *obj);
typedef void (*i2c_init_t)(i2c_t *obj, PinName sda, PinName scl);
typedef int (*i2c_read_t)(i2c_t *obj, int address, char *data, int length, int stop);
typedef int (*i2c_write_t)(i2c_t *obj, int address, const char *data, int length, int stop);
typedef int (*i2c_byte_read_t)(i2c_t *obj, int last);
typedef int (*i2c_byte_write_t)(i2c_t *obj, int data);
typedef void (*pwmout_free_t)(pwmout_t* obj);
typedef void (*pwmout_init_t)(pwmout_t* obj, PinName pin);
typedef void (*pwmout_pulsewidth_us_t)(pwmout_t* obj, int us);
typedef void (*rtc_init_t)(void);
typedef void (*rtc_free_t)(void);
typedef int (*rtc_isenabled_t)(void);
typedef time_t (*rtc_read_t)(void);
typedef void (*rtc_write_t)(time_t t);
typedef void (*serial_baud_t)(serial_t *obj, int baudrate);
typedef void (*serial_init_t)(serial_t *obj, PinName tx, PinName rx);
typedef int (*serial_readable_t)(serial_t *obj);
typedef int (*serial_getc_t)(serial_t *obj);
typedef void (*serial_putc_t)(serial_t *obj, int c);
typedef uint32_t (*us_ticker_read_t)(void);
typedef void (*wait_ms_t)(int ms);
typedef bool (*SD_begin_t)();
typedef int (*usrcmd_cd_t)(int argc, char **argv);
typedef int (*usrcmd_ls_t)(int argc, char **argv);
typedef int (*usrcmd_cp_t)(int argc, char **argv);
typedef int (*usrcmd_rm_t)(int argc, char **argv);
typedef int (*usrcmd_mv_t)(int argc, char **argv);
typedef int (*usrcmd_mkdir_t)(int argc, char **argv);
typedef int (*usrcmd_hexdump_t)(int argc, char **argv);
typedef int (*usrcmd_info_t)(int argc, char **argv);
typedef int (*usrcmd_exit_t)(int argc, char **argv);
typedef void(*shell_abort_t)();
typedef void(*shell_exit_t)(int exitcd);
typedef int (*shell_kill_t)(int pid, int sig);
typedef int (*shell_gettimeofday_t)(struct timeval * tp, void * tzvp);
typedef void (*vsyslog_t)(int priority, const char *format, va_list ap);
typedef int (*shell_open_t)(const char * path, int flags);
typedef int (*shell_close_t)(int fd);
typedef int (*shell_read_t)(int fd, char *data, int len);
typedef int (*shell_write_t)(int fd, char *data, int len);
typedef int (*shell_lseek_t)(int fd, int ptr, int dir);
typedef int (*shell_fstat_t)(int fd, struct stat * st);
typedef int (*shell_stat_t)(const char *fname, struct stat *st);
typedef int (*shell_link_t)(void);
typedef int (*shell_unlink_t)(const char *path);
typedef int (*shell_isatty_t)(int fd);
typedef int (*fsync_t)(int fd);
typedef int (*ftruncate_t)(int fd, off_t length);
typedef int (*ioctl_t)(int fd, int request, va_list ap);
typedef int (*tcgetattr_t)(int fd, struct termios *termios_p);
typedef int (*tcsetattr_t)(int fd, int optional_actions, const struct termios *termios_p);
typedef int (*shell_rename_t)(const char *oldpath, const char *newpath);
typedef int (*rmdir_t)(const char *path);
typedef int (*mkdir_t)(const char *path, mode_t mode);
typedef int (*chmod_t)(const char *path, mode_t mode);
typedef char *(*getcwd_t)(char *buf, size_t size);
typedef int (*chdir_t)(const char *path);
typedef int (*chroot_t)(const char *path);
typedef int (*closedir_t)(DIR *dir);
typedef DIR *(*opendir_t)(const char *path);
typedef struct dirent *(*readdir_t)(DIR *dir);
typedef void (*rewinddir_t)(DIR *dir);
typedef void (*seekdir_t)(DIR *dir, long pos);
typedef long (*telldir_t)(DIR *dir);
typedef int (*shell_getpid_t)();
typedef int (*socket_t)(int family, int type, int protocol);
typedef int (*bind_t)(int fd, const struct sockaddr *addr, socklen_t len);
typedef int (*listen_t)(int fd, int backlog);
typedef int (*connect_t)(int fd, const struct sockaddr *addr, socklen_t len);
typedef int (*accept_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef ssize_t (*send_t)(int fd, const void *buf, size_t len, int flags);
typedef ssize_t (*sendto_t)(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen);
typedef ssize_t (*recv_t)(int fd, void *buf, size_t len, int flags);
typedef ssize_t (*recvfrom_t)(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen);
typedef int (*shutdown_t)(int fd, int how);
typedef int (*getsockopt_t)(int fd, int level, int optname, void *optval, socklen_t *optlen);
typedef int (*setsockopt_t)(int fd, int level, int optname, const void *optval, socklen_t optlen);
typedef int (*select_t)(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv);
typedef int (*poll_t)(struct pollfd *fds, nfds_t nfds, int timeout);
typedef int (*gethostname_t)(char *name, size_t len);
typedef int (*getnameinfo_t)(const struct sockaddr *sa, socklen_t sl, char *node, socklen_t nodelen, char *serv, socklen_t servlen, int flags);
typedef int (*getpeername_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef int (*getsockname_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef int (*socketpair_t)(int family, int type, int protocol, int fd[2]);

void analogin_init(analogin_t *obj, PinName pin)
{
        __imp_analogin_init(obj, pin);
}

uint16_t analogin_read_u16(analogin_t *obj)
{
        return __imp_analogin_read_u16(obj);
}

void gpio_init(gpio_t *obj, PinName pin)
{
        __imp_gpio_init(obj, pin);
}

void gpio_dir(gpio_t *obj, PinDirection direction)
{
        __imp_gpio_dir(obj, direction);
}

int i2c_start(i2c_t *obj)
{
        return __imp_i2c_start(obj);
}

int i2c_stop(i2c_t *obj)
{
        return __imp_i2c_stop(obj);
}

void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{
        __imp_i2c_init(obj, sda, scl);
}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
        return __imp_i2c_read(obj, address, data, length, stop);
}

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
        return __imp_i2c_write(obj, address, data, length, stop);
}

int i2c_byte_read(i2c_t *obj, int last)
{
        return __imp_i2c_byte_read(obj, last);
}

int i2c_byte_write(i2c_t *obj, int data)
{
        return __imp_i2c_byte_write(obj, data);
}

void pwmout_free(pwmout_t* obj)
{
        __imp_pwmout_free(obj);
}

void pwmout_init(pwmout_t* obj, PinName pin)
{
        __imp_pwmout_init(obj, pin);
}

void pwmout_pulsewidth_us(pwmout_t* obj, int us)
{
        __imp_pwmout_pulsewidth_us(obj, us);
}

void rtc_init(void)
{
        __imp_rtc_init();
}

void rtc_free(void)
{
        __imp_rtc_free();
}

int rtc_isenabled(void)
{
        return __imp_rtc_isenabled();
}

time_t rtc_read(void)
{
        return __imp_rtc_read();
}

void rtc_write(time_t t)
{
        __imp_rtc_write(t);
}

void serial_baud(serial_t *obj, int baudrate)
{
        __imp_serial_baud(obj, baudrate);
}

void serial_init(serial_t *obj, PinName tx, PinName rx)
{
        __imp_serial_init(obj, tx, rx);
}

int serial_readable(serial_t *obj)
{
        return __imp_serial_readable(obj);
}

int serial_getc(serial_t *obj)
{
        return __imp_serial_getc(obj);
}

void serial_putc(serial_t *obj, int c)
{
        __imp_serial_putc(obj, c);
}

uint32_t us_ticker_read(void)
{
        return __imp_us_ticker_read();
}

void wait_ms(int ms)
{
        __imp_wait_ms(ms);
}

bool SD_begin()
{
        return __imp_SD_begin();
}

int usrcmd_cd(int argc, char **argv)
{
        return __imp_usrcmd_cd(argc, argv);
}

int usrcmd_ls(int argc, char **argv)
{
        return __imp_usrcmd_ls(argc, argv);
}

int usrcmd_cp(int argc, char **argv)
{
        return __imp_usrcmd_cp(argc, argv);
}

int usrcmd_rm(int argc, char **argv)
{
        return __imp_usrcmd_rm(argc, argv);
}

int usrcmd_mv(int argc, char **argv)
{
        return __imp_usrcmd_mv(argc, argv);
}

int usrcmd_mkdir(int argc, char **argv)
{
        return __imp_usrcmd_mkdir(argc, argv);
}

int usrcmd_hexdump(int argc, char **argv)
{
        return __imp_usrcmd_hexdump(argc, argv);
}

int usrcmd_info(int argc, char **argv)
{
        return __imp_usrcmd_info(argc, argv);
}

int usrcmd_exit(int argc, char **argv)
{
        return __imp_usrcmd_exit(argc, argv);
}

void abort()
{
        __imp_shell_abort();
}

void _exit(int exitcd)
{
        __imp_shell_exit(exitcd);
}

int _kill(int pid, int sig)
{
        return __imp_shell_kill(pid, sig);
}

int _gettimeofday(struct timeval * tp, void * tzvp)
{
        return __imp_shell_gettimeofday(tp, tzvp);
}

void vsyslog(int priority, const char *format, va_list ap)
{
        __imp_vsyslog(priority, format, ap);
}

void syslog(int priority, const char *format, ...)
{
        va_list ap;
        va_start(ap, format);
        vsyslog(priority, format, ap);
        va_end(ap);
}

int _open(const char * path, int flags)
{
        return __imp_shell_open(path, flags);
}

int _close(int fd)
{
        return __imp_shell_close(fd);
}

int _read(int fd, char *data, int len)
{
        return __imp_shell_read(fd, data, len);
}

int _write(int fd, char *data, int len)
{
        return __imp_shell_write(fd, data, len);
}

int _lseek(int fd, int ptr, int dir)
{
        return __imp_shell_lseek(fd, ptr, dir);
}

int _fstat(int fd, struct stat * st)
{
        return __imp_shell_fstat(fd, st);
}

int _stat(const char *fname, struct stat *st)
{
        return __imp_shell_stat(fname, st);
}

int _link(void)
{
        return __imp_shell_link();
}

int _unlink(const char *path)
{
        return __imp_shell_unlink(path);
}

int _isatty(int fd)
{
        return __imp_shell_isatty(fd);
}

int fsync(int fd)
{
        return __imp_fsync(fd);
}

int ftruncate(int fd, off_t length)
{
        return __imp_ftruncate(fd, length);
}

int ioctl(int fd, int request, ...)
{
        int result;
        va_list ap;
        va_start(ap, request);
        result = __imp_ioctl(fd, request, ap);
        va_end(ap);
        return result;
}

int tcgetattr(int fd, struct termios *termios_p)
{
        return __imp_tcgetattr(fd, termios_p);
}

int tcsetattr(int fd, int optional_actions, const struct termios *termios_p)
{
        return __imp_tcsetattr(fd, optional_actions, termios_p);
}

int _rename(const char *oldpath, const char *newpath)
{
        return __imp_shell_rename(oldpath, newpath);
}

int rmdir(const char *path)
{
        return __imp_rmdir(path);
}

int mkdir(const char *path, mode_t mode)
{
        return __imp_mkdir(path, mode);
}

int chmod(const char *path, mode_t mode)
{
        return __imp_chmod(path, mode);
}

char *getcwd(char *buf, size_t size)
{
        return __imp_getcwd(buf, size);
}

int chdir(const char *path)
{
        return __imp_chdir(path);
}

int chroot(const char *path)
{
        return __imp_chroot(path);
}

int closedir(DIR *dir)
{
        return __imp_closedir(dir);
}

DIR *opendir(const char *path)
{
        return __imp_opendir(path);
}

struct dirent *readdir(DIR *dir)
{
        return __imp_readdir(dir);
}

void rewinddir(DIR *dir)
{
        __imp_rewinddir(dir);
}

void seekdir(DIR *dir, long pos)
{
        __imp_seekdir(dir, pos);
}

long telldir(DIR *dir)
{
        return __imp_telldir(dir);
}

int _getpid()
{
        return __imp_shell_getpid();
}

int socket(int family, int type, int protocol)
{
        return __imp_socket(family, type, protocol);
}

int bind(int fd, const struct sockaddr *addr, socklen_t len)
{
        return __imp_bind(fd, addr, len);
}

int listen(int fd, int backlog)
{
        return __imp_listen(fd, backlog);
}

int connect(int fd, const struct sockaddr *addr, socklen_t len)
{
        return __imp_connect(fd, addr, len);
}

int accept(int fd, struct sockaddr *addr, socklen_t *len)
{
        return __imp_accept(fd, addr, len);
}

ssize_t send(int fd, const void *buf, size_t len, int flags)
{
        return __imp_send(fd, buf, len, flags);
}

ssize_t sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
{
        return __imp_sendto(fd, buf, len, flags, addr, alen);
}

ssize_t recv(int fd, void *buf, size_t len, int flags)
{
        return __imp_recv(fd, buf, len, flags);
}

ssize_t recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen)
{
        return __imp_recvfrom(fd, buf, len, flags, addr, alen);
}

int shutdown(int fd, int how)
{
        return __imp_shutdown(fd, how);
}

int getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
{
        return __imp_getsockopt(fd, level, optname, optval, optlen);
}

int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
{
        return __imp_setsockopt(fd, level, optname, optval, optlen);
}

int select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv)
{
        return __imp_select(n, rfds, wfds, efds, tv);
}

int poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
        return __imp_poll(fds, nfds, timeout);
}

unsigned if_nametoindex(const char *name)
{
        return 1;
}

int gethostname(char *name, size_t len)
{
        return __imp_gethostname(name, len);
}

int getnameinfo(const struct sockaddr *sa, socklen_t sl,
        char *node, socklen_t nodelen,
        char *serv, socklen_t servlen,
        int flags)
{
        return __imp_getnameinfo(sa, sl, node, nodelen, serv, servlen, flags);
}

int getpeername(int fd, struct sockaddr *addr, socklen_t *len)
{
        return __imp_getpeername(fd, addr, len);
}

int getsockname(int fd, struct sockaddr *addr, socklen_t *len)
{
        return __imp_getsockname(fd, addr, len);
}

int socketpair(int family, int type, int protocol, int fd[2])
{
        return __imp_socketpair(family, type, protocol, fd);
}

char *basename(char *s)
{
        size_t i, j;
        if (!s || !*s) return ".";
        i = strlen(s) - 1;
        for (j = 0; j <= i; j++) if (s[j] == ':') { s = &s[j + 1]; i -= j; break; }
        for (; i&&s[i] == '/'; i--) s[i] = 0;
        for (; i&&s[i - 1] != '/'; i--);
        return s + i;
}

char *dirname(char *_s)
{
        char *s = _s;
        size_t i, j;
        if (!s || !*s) return ".";
        i = strlen(s) - 1;
        for (j = 0; j <= i; j++) if (s[j] == ':') { s = &s[j + 1]; i -= j; break; }
        for (; s[i] == '/'; i--) if (!i) return (s == _s) ? "/" : _s;
        for (; s[i] != '/'; i--) if (!i) return (s == _s) ? "." : _s;
        for (; s[i] == '/'; i--) if (!i) if (s == _s) return "/"; else break;
        s[i + 1] = 0;
        return _s;
}

char *realpath(const char *filename, char *resolved)
{
        char *path = getcwd(resolved, 256);

        if (path != NULL)
                strcat(path, filename);

        return path;
}

uint32_t htonl(uint32_t n)
{
        return (n >> 24) | ((n >> 8) & 0xFF00) | ((n << 8) & 0xFF0000) | (n << 24);
}

uint32_t ntohl(uint32_t n)
{
        return (n >> 24) | ((n >> 8) & 0xFF00) | ((n << 8) & 0xFF0000) | (n << 24);
}

uint16_t htons(uint16_t n)
{
        return ((n >> 8) & 0xFF) | ((n << 8) & 0xFF00);
}

uint16_t ntohs(uint16_t n)
{
        return ((n >> 8) & 0xFF) | ((n << 8) & 0xFF00);
}

int mprotect(void *addr, size_t len, int prot)
{
        return 0;
}

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
{
        return 0;
}

unsigned int Utf8_to_Utf16(const char *src, int *code_size)
{
        int i;
        unsigned int uc = 0;
        unsigned char len = 0;

        len = 0;
        if ((src[0] & 0x80) == 0) { uc = src[0] & 0x7F; len = 0; }
        else if ((src[0] & 0xE0) == 0xC0) { uc = src[0] & 0x1F; len = 1; }
        else if ((src[0] & 0xF0) == 0xE0) { uc = src[0] & 0x0F; len = 2; }
        else if ((src[0] & 0xF8) == 0xF0) { uc = src[0] & 0x07; len = 3; }
        else if ((src[0] & 0xFC) == 0xF8) { uc = src[0] & 0x03; len = 4; }
        else if ((src[0] & 0xFE) == 0xFC) { uc = src[0] & 0x01; len = 5; }

        i = 1;
        while ((i <= len) && ((src[i] & 0xC0) == 0x80)) {
                uc = (uc << 6) | (src[i] & 0x3F);
                i++;
        }

        //Á”Žš”Ý’è
        *code_size = i;

        //Œ»óA2ƒoƒCƒgŒÀ’è
        return uc;
}

int bs_char_count(char *str, int pos)
{
        int num = 1, local_pos = pos;
        char *c;

        while (1) {
                c = str + local_pos;

                if ((*c & 0x80) != 0x80)
                        return num;

                if (((*c & 0xE0) == 0xC0) && (num == 2)) {
                        return num;
                }
                else if (((*c & 0xF0) == 0xE0) && (num == 3)) {
                        return num;
                }
                else if (((*c & 0xF8) == 0xF0) && (num == 4)) {
                        return num;
                }
                else if (((*c & 0xFC) == 0xF8) && (num == 5)) {
                        return num;
                }
                else if (((*c & 0xFE) == 0xFC) && (num == 6)) {
                        return num;
                }
                else {
                        if (local_pos > 0) {
                                local_pos--;
                                num++;
                        }
                        else
                                return 0;
                }
        }

        return 0;
}