tools.cpp

Go to the documentation of this file.

 
#ifdef CPLUSPLUS
    #undef CPLUSPLUS
#endif
 
 
#include "tools.h"
#include "jbxl_state.h"
 
 
int   DebugMode     = OFF;
int   UnitTestMode  = OFF;
 
int   KanjiCode     = CODE_UTF8;                    
int   HostEndian    = UNKNOWN_ENDIAN;               
 
unsigned long int UsedMemoryBase = 0;               
 
//
unsigned char  LocalIPNum[4]   = {0x7f, 0x00, 0x00, 0x01};    
unsigned char  LocalIPNum6[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; 
 
 
// 
 
// case of C++, isNull() is inline
 
#ifndef CPLUSPLUS
 
int  isNull(void* p)
{
    if (p==NULL) return TRUE;
 
#ifdef WIN32
    if (p==WIN_DD_NULL) return TRUE;
#endif
 
    return FALSE;
}
 
#endif
 
 
// 
 
int is_little_endian(void)
{
    unsigned char x[] = {0x01, 0x00};
 
    if (HostEndian==LITTLE_ENDIAN) return TRUE;
 
    else if (HostEndian==BIG_ENDIAN) return FALSE;
 
    else {
        unsigned short* xx = (unsigned short*)x;
        if (*xx==1) {
            HostEndian = LITTLE_ENDIAN;
            return TRUE;
        }
        else {
            HostEndian = BIG_ENDIAN;
            return FALSE;
        }
    }
}
 
 
int is_big_endian(void)
{
    unsigned char x[] = {0x00, 0x01};
 
    if (HostEndian==BIG_ENDIAN) return TRUE;
 
    else if (HostEndian==LITTLE_ENDIAN) return FALSE;
 
    else {
        unsigned short* xx = (unsigned short*)x;
        if (*xx==1) {
            HostEndian = BIG_ENDIAN;
            return TRUE;
        }
        else {
            HostEndian = LITTLE_ENDIAN;
            return FALSE;
        }
    }
}
 
 
void  check_endian(void)
{
    if (HostEndian==UNKNOWN_ENDIAN) is_little_endian();
} 
 
 
double double_from_little_endian(void* ptr)
{
    double ret = *((double*)ptr);
    
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 8);
    return ret;
}
 
 
float float_from_little_endian(void* ptr)
{
    float ret = *((float*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
int  int_from_little_endian(void* ptr)
{
    int ret = *((int*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
unsigned int  uint_from_little_endian(void* ptr)
{
    unsigned int ret = *((unsigned int*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
short short_from_little_endian(void* ptr)
{
    short ret = *((short*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}
 
 
unsigned short ushort_from_little_endian(void* ptr)
{
    unsigned short ret = *((unsigned short*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}
 
 
double double_from_big_endian(void* ptr)
{
    double ret = *((double*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 8);
    return ret;
}
 
 
float float_from_big_endian(void* ptr)
{
    float ret = *((float*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
int  int_from_big_endian(void* ptr)
{
    int ret = *((int*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
unsigned int  uint_from_big_endian(void* ptr)
{
    int ret = *((unsigned int*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}
 
 
short short_from_big_endian(void* ptr)
{
    short ret = *((short*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}
 
 
unsigned short ushort_from_big_endian(void* ptr)
{
    unsigned short ret = *((unsigned short*)ptr);
 
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}
 
 
// Time
 
//char  _Local_Time[64];      ///< 作業用（ローカルタイム）
 
 
/*
char*  get_localtime(char c1, char c2, char c3, char c4)
{
    struct tm* pt;
    time_t tm;
 
    tm = time(NULL);
    pt = localtime(&tm);
 
    snprintf(_Local_Time, 63, "%04d%c%02d%c%02d%c%02d%c%02d%c%02d%c",
                pt->tm_year+1900, c1, pt->tm_mon+1, c1, pt->tm_mday, c2,
                pt->tm_hour, c3, pt->tm_min, c3, pt->tm_sec, c4);
 
    return _Local_Time;
}
*/
 
 
/*
char*  get_localtime_ts(char c1, char c2, char c3, char c4)
{
    struct tm* pt;
    time_t tm;
    char*  local_tm = NULL;
 
    local_tm = (char*)malloc(64);
    if (local_tm==NULL) return NULL;
    memset(local_tm, 0, 64);
 
    tm = time(NULL);
    pt = localtime(&tm);
 
    snprintf(local_tm, 63, "%04d%c%02d%c%02d%c%02d%c%02d%c%02d%c", 
                pt->tm_year+1900, c1, pt->tm_mon+1, c1, pt->tm_mday, c2, 
                pt->tm_hour, c3, pt->tm_min, c3, pt->tm_sec, c4);
 
    return local_tm;
}
*/
 
 
// 要 free
// char* ltime = get_local_timestamp(time(0), "%Y/%m/%dT%H:%M:%SZ")
//
char*  get_local_timestamp(time_t date, const char* format)
{
    char* buf = (char*)malloc(64);
    memset(buf, 0, 64);
 
    //struct tm tm = *gmtime(&date);
    struct tm tm = *localtime(&date);
    strftime(buf, 63, format, &tm);
 
    return buf;
}
 
 
// 要 free
char*  get_gmt_timestamp(time_t date, const char* format)
{
    char* buf = (char*)malloc(64);
    memset(buf, 0, 64);
 
    struct tm tm = *gmtime(&date);
    //struct tm tm = *localtime(&date);
    strftime(buf, 63, format, &tm);
 
    return buf;
}
 
 
 
char*  get_line(char* buf, int n)
{
    int   i, j, pos, cnt;
    char* ret = NULL;
 
    if (buf==NULL) return NULL;
 
    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
        while (buf[i]==CHAR_LF || buf[i]==CHAR_CR) i++;
    }
    if (buf[i]=='\0') return  NULL;
 
    pos = i;
    while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
    cnt = i - pos;
 
    if (cnt>=0) {  
        ret = (char*)malloc(cnt+1);
        if (ret==NULL) return NULL;
 
        for(i=0; i<cnt; i++) ret[i] = buf[pos+i];
        ret[cnt] = '\0';
    }
    return  ret;
}
 
 
char*  get_seq_data(char* buf, int* ptr)
{
    int   pos, cnt;
    char* ret = NULL;
 
    if (buf==NULL || buf[*ptr]=='\0') return NULL;
 
    pos = *ptr;
    while (buf[*ptr]!=CHAR_LF && buf[*ptr]!=CHAR_CR && buf[*ptr]!='\0') (*ptr)++;
    cnt = *ptr - pos;
 
    if (cnt>=0) {  
        ret = (char*)malloc(cnt+1);
        if (ret==NULL) return NULL;
 
        int i;
        for(i=0; i<cnt; i++) ret[i] = buf[pos+i];
        ret[cnt] = '\0';
    }
 
    while (buf[*ptr]==CHAR_LF || buf[*ptr]==CHAR_CR) (*ptr)++;
    return  ret;
}
 
 
char*  awk(char* buf, char cc, int n)
{
    int i, j, pos, cnt;
    char*  item = NULL;
 
    if (buf==NULL) return NULL;
 
    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!='\0' && buf[i]!=cc) i++;
        if (buf[i]==cc) i++;
    }
    if (buf[i]=='\0')  return NULL;
 
    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;
 
    item = (char*)malloc(cnt+1);
    if (item==NULL) return NULL;
 
    for (i=0; i<cnt; i++) item[i] = buf[pos+i];
    item[cnt] = '\0';
 
    return item;
}
 
 
char*  cawk(char* buf, char cc, int n)
{
    int i, j, pos, cnt;
    char*  item = NULL;
 
    if (buf==NULL) return NULL;
 
    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!='\0' && buf[i]!=cc) i++;
        while (buf[i]!='\0' && buf[i]==cc) i++;
    }
    if (buf[i]=='\0') return NULL;
 
    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;
 
    item = (char*)malloc(cnt+1);
    if (item==NULL) return NULL;
 
    for (i=0; i<cnt; i++) item[i] = buf[pos+i];
    item[cnt] = '\0';
 
    return item;
}
 
 
int  bincmp(unsigned char* b1, unsigned char* b2, int n) 
{
    int i;
 
    if (b1==NULL || b2==NULL) return 1;
 
    for (i=0; i<n; i++) {
        if (b1[i]!=b2[i]) return 1;
    }
 
    return 0;
}
 
 
int  strnrvscmp(const char* s1, const char* s2, int n) 
{
    int j1, j2;
    
    if (s1==NULL || s2==NULL) return 1;
 
    j1 = (int)strlen(s1) - 1;
    j2 = (int)strlen(s2) - 1;
 
    while (n>0 && j1>=0 && j2>=0) {
        if (s1[j1--] != s2[j2--]) return 1;
        n--;
    }
 
    if (n==0) return 0;
    else      return 1;
}
 
 
int  strncaservscmp(const char* s1, const char* s2, int n) 
{
    int j1, j2;
    
    if (s1==NULL || s2==NULL) return 1;
 
    j1 = (int)strlen(s1) - 1;
    j2 = (int)strlen(s2) - 1;
 
    while (n>0 && j1>=0 && j2>=0) {
        if (toupper(s1[j1--]) != toupper(s2[j2--])) return 1;
        n--;
    }
 
    if (n==0) return 0;
    else      return 1;
}
 
 
char*  strstrcase(const char* buf, const char* nd)
{
    char* pp;
    char* pb;
    char* pn;
 
    if (buf==NULL || nd==NULL) return NULL;
 
    pb = (char*)malloc(strlen(buf)+1);
    if (pb==NULL) return NULL;
    memcpy(pb, buf, (int)strlen(buf)+1);
 
    pn = (char*)malloc(strlen(nd)+1);
    if (pn==NULL) {
        free(pb);
        return NULL;
    }
    memcpy(pn, nd, (int)strlen(nd)+1);
 
    upper_string(pb);
    upper_string(pn);
 
    pp = strstr(pb, pn);
    if (pp!=NULL) {
        pp = (pp - pb) + (char*)buf;
    }
    free(pb);
    free(pn);
 
    return pp;
}
 
 
int  ex_strncmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;
 
    if (len==0) {
        if (!strcmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}
 
 
int  ex_strncasecmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;
 
    if (len==0) {
        if (!strcasecmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncasecmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncasecmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}
 
 
int  ex_strnrvscmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;
 
    if (len==0) {
        if (!strcmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strnrvscmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strnrvscmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}
 
 
int  ex_strncaservscmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;
 
    if (len==0) {
        if (!strcasecmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncaservscmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncaservscmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}
 
 
char*  chomp(char* buf)
{
    int i, len;
    
    if (buf==NULL) return NULL;
 
    len = (int)strlen(buf);
    for (i=0; i<len; i++) {
        if (buf[i]==CHAR_LF || buf[i]==CHAR_CR) {
            buf[i] = '\0';
            return buf;
        }
    }
    return buf;
}
 
 
char*  skip_chars(char* pp, const char* check)
{
    int  n, sqf = 0, dqf = 0;
 
    n = (int)strlen(check);
 
    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;
 
            else if (!sqf && !dqf) {
                int i;
                for (i=0; i<n; i++) {
                    if (*pp==check[i]) return pp;
                }
            }
            pp++;
        }
    }
 
    return NULL;
}
 
 
char*  skip_char(char* pp, char cc)
{
    int  sqf = 0, dqf = 0;
 
    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;
            else if (!sqf && !dqf && *pp==cc) return pp;
            pp++;
        }
    }
 
    return pp;
}
 
 
char*   skip_char_pair(char* pp, char pair, char end)
{
    int cnt = 0, sqf = 0, dqf = 0;
 
    if (*pp==pair) {
        cnt = 1;
        pp++;
    }
 
    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;
 
            else if (!sqf && !dqf) {
                if      (*pp==end)  cnt--;
                else if (*pp==pair) cnt++;
                if (cnt==0) return pp;
            }
            pp++;
        }
    }
 
    return pp;
}
 
 
char*  skip_string_end(char* pp)
{
    char ch = *pp;
 
    if (*pp=='\"' || *pp=='\'') {
        pp++;
        //
        while (*pp!='\0') {
            while (*pp=='\\') pp += 2;
            //
            if (*pp!='\0') {
                if (*pp==ch) return pp;
            }
            pp++;
        }
    } 
    return pp;
}
 
 
char*  pack_head_tail_char(char* mesg, char cc)
{
    int   sz;
    char* ps;
    char* pe;
    char* pp;
 
    if (mesg==NULL) return NULL;
 
    ps = mesg;
    while(*ps==cc || *ps==CHAR_TAB || *ps==CHAR_LF || *ps==CHAR_CR) ps++;
    pe = ps;
    while(*pe!='\0') pe++;
    pe--;
    while(*pe==cc || *pe==CHAR_TAB || *pe==CHAR_LF || *pe==CHAR_CR) pe--;
 
    sz = (int)(pe - ps) + 1;
    pp = (char*)malloc((size_t)(sz + 1));
    memcpy(pp, ps, sz);
    pp[sz] = '\0';
 
    return pp;        
}
 
 
/*
char*  pack_char(char* mesg, char cc)
{
    return pack_char_len(mesg, cc, -1);
}
*/
 
 
char*  pack_char_len(char* mesg, char cc, int len)
{
    int i, j;
    int sf = OFF;    // 連続 cc 用のフラグ
    int ff = ON;     // 先頭の cc を無視するためのフラグ
    char* pp;
 
    if (mesg==NULL) return NULL;
 
    if (len==0) return NULL;
    if (len<0)  len = (int)strlen(mesg);
    pp = (char*)malloc(len+1);
    if (pp==NULL) return NULL;
    memset(pp, 0, len+1);
 
    i = j = 0;
    while(mesg[i]!='\0' && i<len) {
        if (mesg[i]==CHAR_TAB)  mesg[i] = ' ';
        if (mesg[i]!=CHAR_CR && mesg[i]!=CHAR_LF) {        // CR LF を読み飛ばす．
            if (mesg[i]==cc) {
                if (sf==OFF) {
                    sf = ON;
                    if (ff==ON) ff = OFF;
                    else  pp[j++] = mesg[i];
                }
            }
            else {
                sf = ff = OFF;
                pp[j++] = mesg[i];
            }
        }
        i++;
    }
    pp[j] = '\0';
 
    // 末尾の cc を削除
    i = (int)strlen(pp) - 1;
    while(i>=0) {
        if (pp[i]==cc) i--; 
        else  break;
    }
    pp[i+1] = '\0';
 
    return pp;
}
 
 
char*  change_esc(char* mesg)
{
    int i, j;
    char* pp;
 
    if (mesg==NULL) return NULL;
 
    pp = (char*)malloc((strlen(mesg)+1)*2);
    if (pp==NULL) return NULL;
    memset(pp, 0, (strlen(mesg)+1)*2);
 
    i = j = 0;
    while(mesg[i]!='\0') {
        if (mesg[i]==CHAR_CR) {
            pp[j++] = '\\';
            pp[j++] = 'r';
        }
        else if (mesg[i]==CHAR_LF) {
            pp[j++] = '\\';
            pp[j++] = 'n';
        }
        else {
            pp[j++] = mesg[i];
        }
        i++;
    }
    pp[j] = '\0';
    
    return pp;
}
 
 
void   replace_char(unsigned char* buf, int len, unsigned char frm, unsigned char toc)
{
    if (buf==NULL) return;
    if (len<=0) len = (int)strlen((char*)buf) + 1;
 
    int i;
    for (i=0; i<len; i++) {
        if (buf[i]==frm) buf[i] = toc;
    }
 
    return;
}
 
 
char*  replace_str(char* buf, int len, const char* frm, const char* tos)
{
    char* wrk = NULL;
    int i, j, k, slen, flen, tlen;
 
    if (buf==NULL || frm==NULL || tos==NULL) return NULL;
    if (len<=0) len = (int)strlen(buf) + 1;
 
    wrk = (char*)malloc(len);
    if (wrk==NULL) return NULL;
    memset(wrk, 0, len);
 
    slen = (int)strlen(buf);
    flen = (int)strlen(frm);
    tlen = (int)strlen(tos);
 
    i = j = 0;
    while (i<slen && j<len) {
        if (!strncmp((const char*)(buf+i), frm, flen)){
            for (k=0; k<tlen; k++) {
                wrk[j+k] = tos[k];
            }
            i += flen;
            j += tlen;
        }
        else {
            wrk[j++] = buf[i++];
        }
    }
 
    //
    if (j>=len) {
        free(wrk);
        return NULL;
    }
 
    wrk[j] = '\0';
    for (k=0; k<=j; k++) buf[k] = wrk[k];
    free(wrk);
 
    return buf;
}
 
 
char*  cut_str(char* buf, int ls, int le)
{
    int   i, len;
    char* ret;
 
    if (buf==NULL) return NULL;
 
    ls  = Max(ls, 0);
    le  = Min(le, (int)strlen((const char*)buf)); 
    len = le - ls + 1;
    if (len<=0) return NULL;
 
    ret = (char*)malloc(len+1);
    if (ret==NULL) return NULL;
    memset(ret, 0, len+1);
 
    for (i=0; i<len; i++) ret[i] = buf[i+ls];
 
    return ret;
}
 
 
char*  dup_str(char* buf)
{
    int   len;
    char* ret;
 
    if (buf==NULL) return NULL;
 
    len = (int)strlen(buf);
    ret = (char*)malloc(len+1);
    if (ret==NULL) return NULL;
 
    memcpy(ret, buf, len);
    ret[len] = '\0';
 
    return ret;
}
 
 
int   is_number(unsigned char* str)
{
    if (str==NULL) return 0;
    int i, len = (int)strlen((char*)str);
 
    int cnt = 0;
    for (i=0; i<len; i++) {
        if (str[i]=='.') cnt += 1;
        else if (str[i]<'0' || str[i]>'9') return 0;
    }
    if (cnt>1) return 0;
    else if (cnt>0) return 2;
    return 1;
}
 
 
static char  _ToSTR[LDATA];        
 
char*  itostr(int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%d", n);
    return _ToSTR;
}
 
 
char*  ltostr(long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%ld", n);
    return _ToSTR;
}
 
 
char*  ultostr(unsigned long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%lu", n);
    return _ToSTR;
}
 
 
char*  lltostr(long long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%lld", n);
    return _ToSTR;
}
 
 
char*  ulltostr(unsigned long long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%llu", n);
    return _ToSTR;
}
 
 
char*  ftostr(float n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%f", n);
    return _ToSTR;
}
 
 
char*  dtostr(double n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%f", n);
    return _ToSTR;
}
 
 
char*  itostr_ts(int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%d", n);
    return str;
}
 
 
char*  ltostr_ts(long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%ld", n);
    return str;
}
 
 
char*  ultostr_ts(unsigned long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%lu", n);
    return str;
}
 
 
char*  lltostr_ts(long long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%lld", n);
    return str;
}
 
 
char*  ulltostr_ts(unsigned long long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%llu", n);
    return str;
}
 
 
char*  ftostr_ts(float n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%f", n);
    return str;
}
 
 
char*  dtostr_ts(double n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;
 
    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%f", n);
    return str;
}
 
 
int  count_lines(const char* buf)
{
    int i    = 0;
    int line = 0;
    
    if (buf==NULL) return 0;
    line++;
 
    while(buf[i]!='\0') {
        if (buf[i]==CHAR_CR) {
            line++;
            if (buf[i+1]==CHAR_LF) i++;
        }
        else if (buf[i]==CHAR_LF) {
            line++;
        }
        i++;
    }
 
    return line;
}
 
 
int hexstr2i(const char* str)
{
    int i, ret = 0;
    if (str==NULL) return ret;
 
    int len = (int)strlen(str);
 
    for (i=0; i<len; i++) {
        if (str[i]>='0' && str[i]<='9') {
            ret = ret*16;
            ret += (int)(str[i] - '0');
        }
        else if (str[i]>='A' && str[i]<='F') {
            ret = ret*16;
            ret += (int)(str[i] - 'A') + 10;
        }
        else if (str[i]>='a' && str[i]<='f') {
            ret = ret*16;
            ret += (int)(str[i] - 'a') + 10;
        }
        else if (str[i]!=' ') {
            break;
        }
    }
 
    return ret;
}
 
 
#ifndef WIN32
 
void  init_rand(void)
{
    FILE* fp;
    unsigned int seed;
    size_t sz;
    UNUSED(sz);
 
    fp = fopen("/dev/urandom", "rb");
    if (fp==NULL) {
        srand(time(NULL));
        return;
    }
    sz = fread(&seed, sizeof(unsigned int), 1, fp);
    fclose(fp);
 
    srand(seed);
}
 
#endif
 
 
char*  randstr(int n)
{
    char   base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    char*  pass;
    int    i, sz;
 
    if (n<=0) return NULL;
    pass = (char*)malloc(n+1);
    if (pass==NULL) return pass;
 
    sz = (int)strlen(base);
    for (i=0; i<n; i++) pass[i] = base[rand()%sz];
    pass[n] = '\0';
 
    return pass;
}
 
 
unsigned char*  randbit(int n)
{
    int   i, sz;
    unsigned char* bin;
 
    sz = (n+7)/8;
    bin = (unsigned char*)malloc(sz);
    if (bin==NULL) return NULL;
 
    memset(bin, 0, sz);
    for (i=0; i<n; i++) setBit(bin, i, rand()%2);
 
    return bin;    
}
 
 
 
//
// 64bit 変換
unsigned long long int ntohull(unsigned long long int s)
{
    if (is_little_endian()) {
        long long int d;
        uByte* src = (uByte*)&s;
        uByte* dst = (uByte*)&d;
        dst[0] = src[7];
        dst[1] = src[6];
        dst[2] = src[5];
        dst[3] = src[4];
        dst[4] = src[3];
        dst[5] = src[2];
        dst[6] = src[1];
        dst[7] = src[0];
        return d;
    }
    return s;
}
 
 
void  swap_byte(void* p, int s, int c)
{
    int    i;
    uByte* u = (uByte*)p;
    for (i=0; i<s; i+=c) reverse_str(&u[i], c);
}
 
 
 
short  swaps(unsigned short p)
{
    short  r;
    uByte* t;
    uByte* f;
     
    t = (uByte*)&r;
    f = (uByte*)&p;
    t[0] = f[1];
    t[1] = f[0];
 
    return r;
}
 
 
int  swapl(unsigned int p)
{
    int    r;
    uByte* t;
    uByte* f;
     
    t = (uByte*)&r;
    f = (uByte*)&p;
    t[0] = f[3];
    t[1] = f[2];
    t[2] = f[1];
    t[3] = f[0];
 
    return r;
}
 
 
long long int swapd(unsigned long long int p)
{
    long long int r;
    uByte* t;
    uByte* f;
     
    t = (uByte*)&r;
    f = (uByte*)&p;
    t[0] = f[7];
    t[1] = f[6];
    t[2] = f[5];
    t[3] = f[4];
    t[4] = f[3];
    t[5] = f[2];
    t[6] = f[1];
    t[7] = f[0];
 
    return r;
}
 
 
void  reverse_str(uByte* p, int s)
{
    int    i;
    uByte  c;
     
    if (s<=0) s = (int)strlen((const char*)p);
 
    for (i=0; i<s/2; i++) {
        c        = p[s-1-i];
        p[s-1-i] = p[i];
        p[i]     = c;
    }
}   
 
 
 
 
int  file_from_to(const char* src, const char* dst, const char* mode)
{
    long int  sz;
    unsigned char* buf;
    FILE*  fp;
    size_t rs;
    UNUSED(rs);
 
    sz = file_size(src);
    if (sz<0) return JBXL_FILE_EXIST_ERROR;
    buf = (unsigned char*)malloc(sz);
    if (buf==NULL) return JBXL_MALLOC_ERROR;
    memset(buf, 0, sz);
 
    fp = fopen(src, "rb");
    if (fp==NULL) {
        free(buf);
        return JBXL_FILE_OPEN_ERROR;
    }
    rs = fread(buf, sz, 1, fp);
    fclose(fp);
 
    fp = fopen(dst, mode);
    if (fp==NULL) {
        free(buf);
        return JBXL_FILE_DESTOPEN_ERROR;
    }
    fwrite(buf, sz, 1, fp);
    fclose(fp);
 
    free(buf);
    return sz;
}
 
 
int  fp_from_to(FILE* src, FILE* dst, long int sz)
{
    unsigned char* buf;
    size_t rs;
    UNUSED(rs);
 
    if (sz<=0)     return JBXL_ARGS_ERROR;
    if (src==NULL) return JBXL_FILE_OPEN_ERROR;
    if (dst==NULL) return JBXL_FILE_DESTOPEN_ERROR;
 
    buf = (unsigned char*)malloc(sz);
    if (buf==NULL) return JBXL_MALLOC_ERROR;
    memset(buf, 0, sz);
 
    rs = fread(buf, sz, 1, src);
    sz = (int)fwrite(buf, sz, 1, dst);
 
    free(buf);
    return sz;
}
 
 
char* get_file_name(const char* str)
{
    if (str==NULL) return NULL;
 
#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif
 
    int len = (int)strlen(str);
    int sz  = 0;
    while (sz<len && str[len-1-sz]!=cc) sz++;
    char* fnm = (char*)str + len - sz; 
 
    return fnm;
}
 
 
char* del_file_name(const char* str)
{
    if (str==NULL) return NULL;
    
#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif
 
    char* path = (char*)str;
    int len = (int)strlen(str);
    if (len==1) {
        if (path[0]==cc) return path;
        else return NULL;
    }
 
    int sz = len - 1;
    while (sz>=0 && str[sz]!=cc) sz--;
 
    if (sz<0) {
        path[0] = '.';
        path[1] = cc;
        path[2] = '\0';
    }
    else {
        path[sz+1] = '\0';
    }
 
    return path;
}
 
 
/*
char* make_file_path(const char* str)
{
    if (str==NULL || str[0]=='\0') return NULL;
 
    int len = (int)strlen(str);
    char* path = (char*)malloc(len+1);
    memcpy(path, str, len+1);
 
#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif
 
    if (len==1) {
        if (path[0]==cc) return path;
        else {
            free(path);
            return NULL;
        }
    }
 
    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;
 
    if (sz<0) {
        if (len>=2) {
            path[0] = '.';
            path[1] = cc;
            path[2] = '\0';
        }
        else {
            free(path);
            path = NULL;
        }
    }
    else {
        path[sz+1] = '\0';
    }
 
    return path;
}
*/
 
 
char* get_file_path(const char* str)
{
    if (str==NULL || str[0]=='\0') return NULL;
 
    int len = (int)strlen(str);
    char* path = (char*)malloc(len + 1);
    memcpy(path, str, len + 1);
 
    char  cc1 = '\\';
    char  cc2 = '/';
 
    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc1 && path[sz]!=cc2) sz--;
 
    if (sz<0) {
        free(path);
        path = NULL;
    }
    else {
        path[sz+1] = '\0';
    }
 
    return path;
}
 
 
char* get_file_extension(const char* str)
{
    int   sz, len;
    char* ext;
 
    if (str==NULL) return NULL;
 
    char  pd  = '.';
    char  cc1 = '\\';
    char  cc2 = '/';
 
    len = (int)strlen(str);
    sz  = 0;
    while (sz<len && str[len-1-sz]!=cc1 && str[len-1-sz]!=cc2 && str[len-1-sz]!=pd) sz++;
 
    if (str[len-1-sz]!=pd) return NULL;
    ext = (char*)str + len - sz; 
 
    return ext;
}
 
 
char* del_file_extension(const char* str)
{
    if (str==NULL) return NULL;
    
    char  cc = '.';
    char* path = (char*)str;
 
    int len = (int)strlen(path);
    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;
 
    if (sz<1) return path;
    path[sz] = '\0';
 
    return path;
}
 
 
char* cut_file_extension(const char* str)
{
    if (str==NULL) return NULL;
 
    char  cc = '.';
    int len = (int)strlen(str);
    char* path = (char*)malloc(len+1);
    memcpy(path, str, len+1);
 
    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;
 
    if (sz<1) return path;
    path[sz] = '\0';
 
    return path;
}
 
 
unsigned long int  file_size(const char* fn)
{
    if (fn==NULL) return -1;
 
    struct stat stbuf;                                               
    stat(fn, &stbuf);
 
#ifdef WIN32
    return stbuf.st_size;
#else
    if (S_ISREG(stbuf.st_mode)) return stbuf.st_size;
    else                        return -2;
#endif
}
 
 
int  file_exist(const char* fn)
{
    FILE* fp;
 
    if (fn==NULL) return FALSE;
 
    if ((fp=fopen(fn,"rb"))==NULL) {
        return FALSE;
    }
    fclose(fp);
    return TRUE;
}
 
 
FILE*  file_chmod_open(const char* fn, const char* fm, mode_t mode)
{
    FILE* fp;
 
    if (!file_exist(fn)) {
        if ((fp=fopen(fn,"wb"))==NULL) return NULL;
        fclose(fp);
    }
 
#ifndef WIN32
    fp = NULL;
    if (chmod(fn, mode)) return fp;
#endif
 
    fp = fopen(fn, fm);
    return fp;
}
 
 
char*  temp_filename(const char* dir, int flen)
{
    FILE* fp;
    int   i, dlen=0;
    char  nostr = '\0';
    char* fname;
    char* fnbin;
    char* fnb64;
    size_t rs;
    UNUSED(rs);
 
    if (dir==NULL) dir = &nostr;
    dlen = (int)strlen(dir);
    if (flen<=0)   flen = 15;
 
    fname = (char*)malloc(dlen+flen+1);
    if (fname==NULL) return NULL;
    memset(fname, 0, dlen+flen+1);
 
    fnbin = (char*)malloc(flen);
    if (fnbin==NULL) {
        free(fname);
        return NULL;
    }
    memset(fnbin, 0, flen);
 
    fnb64 = NULL;
    fp = fopen("/dev/urandom", "rb");
 
    do {
        if (fp!=NULL) {
            rs = fread(fnbin, flen, 1, fp);
            fnb64 = (char*)encode_base64((unsigned char*)fnbin, flen);
            if (fnb64!=NULL) fnb64[flen] = '\0';
        }
        if (fnb64==NULL) fnb64 = randstr(flen);
 
        for (i=0; i<flen; i++) {
            if (fnb64[i]=='/') fnb64[i] = 'x';
            if (fnb64[i]=='+') fnb64[i] = 'X';
        }
 
        memset (fname, 0, dlen+flen+1);
        strncpy(fname, dir, dlen);
        strncat(fname, fnb64, flen);
        free(fnb64);
    } while(file_exist(fname)); 
 
    if (fp!=NULL) fclose(fp);
    free(fnbin);
    return fname;
}
 
 
unsigned char*  read_file(const char* fname, long unsigned int* size)
{
    size_t rs;
    UNUSED(rs);
 
    if (size==NULL) return NULL;
 
    *size = file_size(fname);
    if (*size<=0) return NULL;
 
    unsigned char* buf = (unsigned char*)malloc(*size);
    if (buf==NULL) return NULL;
    memset(buf, 0, *size);
 
    FILE* fp  = fopen(fname, "rb");
    if (fp==NULL) {
        free(buf);
        return NULL;
    }
 
    rs = fread(buf, *size, 1, fp);
    fclose(fp);
 
    return buf;
}
 
 
long unsigned int  write_file(const char* fname, unsigned char* buf, long unsigned int size)
{
    if (size==0) return 0;
 
    FILE* fp = fopen(fname, "wb");
    if (fp==NULL) return 0;
 
    size = (long unsigned int)fwrite(buf, size, 1, fp);
    fclose(fp);
 
    return size;
}
 
 
int  mkdirp(const char* path, mode_t mode)
{
    if (path==NULL) return JBXL_ARGS_ERROR;
 
    long unsigned int lpath  = (long unsigned int)strlen(path);
    char* file_name = (char*)malloc(lpath + 1);
    memcpy(file_name, path, lpath);
    file_name[lpath] = '\0';
    //
    long unsigned int size = 0;
    int  mark = 1;
#ifdef WIN32
    if (file_name[1]==':') mark = 2;    // ex.) "D:/abc/xyz"
#endif
 
    char* wrk = (char*)malloc(lpath + 1);
    while (size < lpath) {
        memcpy(wrk, file_name, lpath + 1);
        int dirs = 0;
        for (long unsigned int ptr=0; ptr<=lpath; ptr++) {
            if (wrk[ptr]=='/')  dirs++;
            if (mark==dirs) {
                wrk[ptr] = '\0';
                struct stat stbuf;
                int ret = stat(wrk, &stbuf);
                if (ret>=0) {
                    if (!(stbuf.st_mode & S_IFDIR)) {
                        return JBXL_FILE_EXIST_ERROR;
                    }
                    break;
                }
                ret = mkdir(wrk, mode);
                if (ret<0) return JBXL_DIR_MAKE_ERROR;
                break;
            }
            size = ptr;
        }
        mark++;
    }
    free(wrk);
    return JBXL_NORMAL;
}
 
 
char* double_bs(char* str) 
{
    int  i, j;
    int  len, bsn=0;
    char* buf;
 
    len = (int)strlen(str);
    for (i=0; i<len; i++) if (str[i]=='\\') bsn++;
    buf = (char*)malloc(len+bsn+1);
    if (buf==NULL) return NULL;
    memset(buf, 0, len+bsn+1);
 
    for (i=0,j=0; i<len; i++) {
        buf[j++] = str[i];
        if (str[i]=='\\') buf[j++] = '\\';
    }
    buf[j] = '\0';
 
    return buf;
}
 
 
char*  numbering_name(const char* fmt, int n)
{
    int    len;
    char   fname[LNAME], *fo;
 
    memset(fname, 0, LNAME);
    snprintf(fname, LNAME-1, fmt, n);
    len = (int)strlen(fname);
 
    fo = (char*)malloc(len+1);
    if (fo==NULL) return NULL;
 
    memset(fo, 0, len+1);
    strncpy(fo, fname, len);
    return fo;
}
 
 
 
 
void kanji_convert(unsigned char* mesg)
{
    if (KanjiCode==CODE_SJIS) {
        kanji_convert_euc2sjis(mesg);
    }
}
 
 
void kanji_convert_euc2sjis(unsigned char* mesg)
{
    int i = 0;
    while(mesg[i]!='\0' && mesg[i+1]!='\0'){
        if (mesg[i]>=0xa1 && mesg[i]<=0xfe){ // EUC
            euc2sjis(&mesg[i], &mesg[i+1]);
            i = i + 2;
        } 
        else  i++;
    }
}
 
 
void kanji_convert_sjis2euc(unsigned char* mesg)
{
    int i = 0;
    while(mesg[i]!='\0' && mesg[i+1]!='\0'){
        // if文が変則的なのは，コンパイラで警告が出るため   (GCC) 3.3.2 20031218 
        if ((mesg[i]>=0x81 && mesg[i]<=0x9f) ||
            (mesg[i]>=0xe0 && mesg[i]<=0xfe) || mesg[i]==0xff) { // SJIS
            sjis2euc(&mesg[i], &mesg[i+1]);
            i = i + 2;
        } 
        else  i++;
    }
}
 
 
void  euc2sjis(unsigned char *c1, unsigned char *c2)
{
    if (*c1%2==0) *c2 -= 0x02;
    else{
        *c2 -= 0x61;
        if (*c2>0x7e) (*c2)++;
    }
 
    if (*c1<0xdf) {
        (*c1)++;
        *c1 /= 2;
        *c1 += 0x30;
    }
    else {
        (*c1)++;
        *c1 /= 2;
        *c1 += 0x70;
    }
}
 
 
void  sjis2euc(unsigned char *c1, unsigned char *c2)
{
    if (*c2<0x9f) {
        if (*c1 < 0xa0) {
            *c1 -= 0x81;
            *c1 *= 2;
            *c1 += 0xa1;
        }
            
        else {
            *c1 -= 0xe0;
            *c1 *= 2;
            *c1 += 0xdf;
        }
        if (*c2>0x7f) (*c2)--;
        *c2 += 0x61;
    }
    else {
        if (*c1<0xa0) {
            *c1 -= 0x81;
            *c1 *= 2;
            *c1 += 0xa2;
        }
        else {
            *c1 -= 0xe0;
            *c1 *= 2;
            *c1 += 0xe0;
        }
        *c2 += 2;
     }
}
 
 
void  upper_string(char* str)
{
    int  i;
    for (i=0; i<(int)strlen((const char*)str); i++) {
        if (str[i]>='a' && str[i]<='z') str[i] += 'A' - 'a';
    }
}
 
 
unsigned char*  decode_base64(unsigned char* buf, int* sz)
{
    int   i, j, cc=0, bas, lt, ln;
    unsigned char* dcd;
 
    lt = 0;
    ln = (int)strlen((const char*)buf);
    while (buf[lt]!='=' && lt<ln) {
        lt++;
        if (lt==ln) break;
    }
 
    int len = lt/4*3 + (lt%4)*3/4;
    if (sz!=NULL) *sz = len;
 
    dcd = (unsigned char*)malloc(len+1);
    if (dcd==NULL) return NULL;
    memset(dcd, 0, len+1);
 
    for (i=0; i<lt; i++) {
        if      (buf[i]>='A' && buf[i]<='Z') cc = buf[i] - 'A';
        else if (buf[i]>='a' && buf[i]<='z') cc = buf[i] - 'a' + 26;
        else if (buf[i]>='0' && buf[i]<='9') cc = buf[i] - '0' + 52;
        else if (buf[i]=='+')                cc = 62;
        else if (buf[i]=='/')                cc = 63;
 
        if (cc<64) {
            bas = 32;
            for (j=0; j<6; j++) {
                setBit(dcd, i*6+j, cc/bas);
                cc = cc%bas;
                bas = bas/2;
            }
        }
    }
    return dcd;
}
 
 
unsigned char*  encode_base64(unsigned char* buf, int sz)
{
    unsigned char  base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    unsigned char  bas;
    int   i, j, len;
    unsigned char*  ecd;
    
    if (buf==NULL) return NULL;
    if (sz<0) len = (int)strlen((const char*)buf);
    else      len = sz;
    if (len<=0) return NULL;
 
    sz  = ((len+2)/3)*4;
    ecd = (unsigned char*)malloc(sz+1);
    if (ecd==NULL) return NULL;
    memset(ecd, 0, sz+1);
 
    for (i=0; i<sz; i++) {
        bas = 0x00;
        if (len*8 > i*6) {
            for (j=0; j<6; j++) {
                if (len*8 > i*6+j) setBit(&bas, j+2, getBit(buf, i*6+j));
                //else               setBit(&bas, j+2, 0);
            }
            ecd[i] = base[(int)bas];
        }
        else {
            ecd[i] = '=';
        }
    }
    return ecd;
}
 
 
unsigned char*  decode_base64_filename(unsigned char* buf, int* sz, unsigned char cc)
{
    if (cc==0x00) cc = '-';
 
    int i, len = (int)strlen((char*)buf);
    for (i=0; i<len; i++) {
        if (buf[i]==cc) buf[i] = '/';
    }
 
    unsigned char* dec = decode_base64(buf, sz);
 
    return dec;
}
 
 
unsigned char*  encode_base64_filename(unsigned char* buf, int sz, unsigned char cc)
{
    if (cc==0x00) cc = '-';
 
    unsigned char* enc = encode_base64(buf, sz);
 
    int i, len = (int)strlen((char*)enc);
    for (i=0; i<len; i++) {
        if (enc[i]=='/') enc[i] = cc;
    }
 
    return enc;
}
 
 
unsigned char*  decode_urlenc(unsigned char* buf, int* sz)
{
    int i, j, len;
    unsigned char* dec;
 
    if (buf==NULL) return NULL;
 
    len = (int)strlen((const char*)buf) + 1;
    dec = (unsigned char*)malloc(len);
    if (dec==NULL) return NULL;
    memset(dec, 0, len);
 
    i = j = 0;
    while (buf[i]!='\0') {
        if (buf[i]=='%') {
            if (buf[i+1]=='\0') return dec;
            if (buf[i+2]=='\0') return dec;
            dec[j++] = decode_hex(buf[i+1], buf[i+2]);
            i += 2;
        }
        else {
            if (buf[i]=='+') dec[j++] = ' ';
            else             dec[j++] = buf[i];
        }
        i++;
    }
 
    *sz = j;
    return dec;
}
                
 
 
unsigned char*  encode_urlenc(unsigned char* buf, int sz)
{
    int i, j, len;
    unsigned char* enc;
 
    if (buf==NULL) return NULL;
 
    if (sz<0) sz = (int)strlen((const char*)buf);
    len = sz*3 + 1;
    enc = (unsigned char*)malloc(len);
    if (enc==NULL) return NULL;
    memset(enc, 0, len);
 
    for(i=0, j=0; i<sz; i++) {
        if (buf[i]==' ') {                                        // 半角スペース
            enc[j++] = '+';
        }
        else if ((buf[i]>=0x30 && buf[i]<=0x39) ||                // 0-9
                 (buf[i]>=0x41 && buf[i]<=0x5a) ||                // A-Z
                 (buf[i]>=0x61 && buf[i]<=0x7a) ||                // a-z
                  buf[i]=='-' || buf[i]=='.' || buf[i]=='_'){     // - . _
            enc[j++] = buf[i];
        }
        else {
            unsigned char* asc = encode_hex(buf[i]);
            if (asc==NULL) {
                free(enc);
                return NULL;
            }
            enc[j++] = '%';
            enc[j++] = asc[0];
            enc[j++] = asc[1];
            free(asc);
        }
    }
 
    return enc;
}    
 
 
unsigned char*  decode_quoted_printable(unsigned char* buf, int* sz)
{
    int    i, j, len;
    unsigned char*  dec;
 
    len = (int)strlen((const char*)buf) + 1;
    dec = (unsigned char*)malloc(len);
    if (dec==NULL) return NULL;
    memset(dec, 0, len);
 
    i = j = 0;
    while (buf[i]!='\0') {
        if (buf[i]=='=') {
            if (buf[i+1]=='\0') return dec;
            if (buf[i+2]=='\0') return dec;
            dec[j++] = decode_hex(buf[i+1], buf[i+2]);
            i += 2;
        }
        else {
            if (buf[i]=='_') dec[j++] = ' ';            // RFC2047
            else             dec[j++] = buf[i];
        }
        i++;
    }
 
    *sz = j;
    return dec;
}
 
 
unsigned char*  encode_quoted_printable(unsigned char* buf, int sz)
{
    int    i, j, len;
    unsigned char*  enc;
 
    if (sz<0) sz = (int)strlen((const char*)buf);
    len = sz*3 + 1;
    enc = (unsigned char*)malloc(len);
    if (enc==NULL) return NULL;
    memset(enc, 0, len);
 
    for (i=0, j=0; i<sz; i++) {
        if (buf[i]=='=') {        // 0x3d
            enc[j++] = '=';
            enc[j++] = '3';
            enc[j++] = 'D';
        }
        else if (buf[i]=='_') {        // 0x5f
            enc[j++] = '=';
            enc[j++] = '5';
            enc[j++] = 'F';
        }
        else if (buf[i]==' ') {        // 0x20  RFC2047
            enc[j++] = '_';
        }
        else if (buf[i]<=0x1f || buf[i]>=0x7f) {
            unsigned char* asc = encode_hex(buf[i]);
            if (asc==NULL) {
                free(enc);
                return NULL;
            }
            enc[j++] = '=';
            enc[j++] = asc[0];
            enc[j++] = asc[1];
            free(asc);
        }
        else {
            enc[j++] = buf[i];
        }
    }
 
    return enc;
}    
 
 
unsigned char*  encode_hex(unsigned char cc)
{
    unsigned char* ret;
    unsigned char  pp1, pp2;
    unsigned char  base[] = "0123456789ABCDEF";
 
    ret = (unsigned char*)malloc(3);
    if (ret==NULL) return NULL;
 
    pp1 = cc >> 4;
    pp2 = cc & 0x0f;
 
    ret[0] = base[pp1];
    ret[1] = base[pp2];
    ret[2] = '\0';
 
    return ret;
}
 
 
unsigned char  decode_hex(unsigned char pp1, unsigned char pp2)
{
    unsigned char ret;
 
    if (pp1>=0x30 && pp1<=0x39)      pp1 -= 0x30;    // 0-9
    else if (pp1>=0x41 && pp1<=0x46) pp1 -= 0x37;    // A-F
    else if (pp1>=0x61 && pp1<=0x66) pp1 -= 0x57;    // a-f
    else                             pp1 =  0x00;
 
    if (pp2>=0x30 && pp2<=0x39)      pp2 -= 0x30;    // 0-9
    else if (pp2>=0x41 && pp2<=0x46) pp2 -= 0x37;    // A-F
    else if (pp2>=0x41 && pp2<=0x46) pp2 -= 0x57;    // a-f
    else                             pp1 =  0x00;
 
    ret = (pp1<<4) + pp2;
    return ret;
}
 
 
 
//  バイト型 リングバッファ
//
 
ringBuffer*  new_ringBuffer(int sz)
{
    ringBuffer* rb;
    
    rb = (ringBuffer*)malloc(sizeof(ringBuffer));
    if (rb==NULL) return NULL;
    memset(rb, 0, sizeof(ringBuffer));
    rb->state = JBXL_NORMAL;
    
    if (sz>0) {
        rb->buf = (unsigned char*)malloc(sz);
        if (rb->buf==NULL) return rb;
        memset(rb->buf, 0, sz);
        rb->bufsz = sz;
    }
    return rb;
}
 
 
void  del_ringBuffer(ringBuffer** rb)
{
    if (rb!=NULL && *rb!=NULL) {
        freeNull((*rb)->buf);
        free(*rb);
        *rb = NULL;
    }
}
 
 
ringBuffer  init_ringBuffer()
{
    ringBuffer  rb;
 
    memset(&rb, 0, sizeof(ringBuffer));
    rb.state = JBXL_NORMAL;
 
    return rb;
}
 
 
ringBuffer  make_ringBuffer(int sz)
{
    ringBuffer  rb;
 
    memset(&rb, 0, sizeof(ringBuffer));
    
    if (sz>0) {
        rb.buf = (unsigned char*)malloc(sz);
        if (rb.buf==NULL) return rb;
        memset(rb.buf, 0, sz);
        rb.bufsz = sz;
        rb.state = JBXL_NORMAL;
    }
 
    return rb;
}
 
 
void  free_ringBuffer(ringBuffer* rb)
{
    if (rb!=NULL) {
        freeNull(rb->buf);
        memset(rb, 0, sizeof(ringBuffer));
        rb->state = JBXL_NORMAL;
    }
}
 
 
void   clear_ringBuffer(ringBuffer* rb)
{
    if (rb!=NULL) {
        int sz = rb->bufsz;
        unsigned char* ptr = rb->buf;
        memset(rb->buf, 0, rb->bufsz);
        memset(rb, 0, sizeof(ringBuffer));
        rb->buf   = ptr;
        rb->state = JBXL_NORMAL;
        rb->bufsz = sz;
    }
}
 
 
int  put_ringBuffer(ringBuffer* rb, unsigned char* pp, int sz)
{
    if (rb==NULL) return JBXL_ARGS_ERROR;
    rb->state = JBXL_NORMAL;
 
    if (pp==NULL)      return JBXL_ARGS_ERROR;
    if (rb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;
    if (rb->datasz+sz>rb->bufsz) {
        rb->state = JBXL_ERROR;
        return JBXL_TOOLS_BUFSZ_ERROR;
    }
 
    if (rb->epoint+sz<=rb->bufsz) {
        memcpy(&(rb->buf[rb->epoint]), pp, sz);
        rb->epoint = rb->epoint + sz;
        if (rb->epoint==rb->bufsz) rb->epoint = 0;
    }
    else {
        memcpy(&(rb->buf[rb->epoint]), pp, rb->bufsz-rb->epoint);
        memcpy(rb->buf, &(pp[rb->bufsz-rb->epoint]), sz-(rb->bufsz-rb->epoint));
        rb->epoint = rb->epoint + sz - rb->bufsz; 
    }
 
    rb->datasz += sz;
    return sz;
}    
 
 
unsigned char*  get_ringBuffer(ringBuffer* rb, int sz)
{
    unsigned char* pp;
 
    if (rb==NULL) return NULL;
    if (rb->buf==NULL) return NULL;
    if (sz>rb->datasz) return NULL;
 
    pp = (unsigned char*)malloc(sz+1);
    if (pp==NULL)  return NULL;
    memset(pp, 0, sz+1);
 
    if (rb->spoint+sz<=rb->bufsz) {
        memcpy(pp, &(rb->buf[rb->spoint]), sz);
        rb->spoint = rb->spoint + sz;
        if (rb->spoint==rb->bufsz) rb->spoint = 0;
    }
    else {
        memcpy(pp, &(rb->buf[rb->spoint]), rb->bufsz-rb->spoint);
        memcpy(&(pp[rb->bufsz-rb->spoint]), rb->buf, sz-(rb->bufsz-rb->spoint));
        rb->spoint = rb->spoint + sz - rb->bufsz; 
    }
 
    rb->datasz -= sz;
    return pp;
}    
 
 
int  seek_ringBuffer(ringBuffer* rb, int sz)
{
    if (rb==NULL) return FALSE;
    if (rb->buf==NULL) return FALSE;
    if (sz>rb->datasz) return FALSE;
 
    if  (rb->spoint+sz>=rb->bufsz) {
        rb->spoint = rb->spoint + sz - rb->bufsz;
    }
    else if (rb->spoint+sz<0) {
        rb->spoint = rb->bufsz + rb->spoint + sz;
    }
    else  {
        rb->spoint = rb->spoint + sz;
    }
 
    rb->datasz -= sz;
    return TRUE;
}    
 
 
unsigned char*  ref_ringBuffer(ringBuffer* rb, int pos)
{
    unsigned char* pp;
 
    if (rb==NULL) return NULL;
    if (rb->buf==NULL) return NULL;
    if (pos>rb->datasz) return NULL;
 
    int sz = rb->spoint + pos;
    pp = rb->buf + sz;
    if (sz >= rb->bufsz) pp -= rb->bufsz;
 
    return pp;
}    
 
 
 
// バイト型 メッセージストリームバッファ
//
 
int  put_mstream(mstream* sb, unsigned char* mesg)
{
    int  i, n, m, cc, np=0, len;
 
    if (sb==NULL)   return JBXL_ARGS_ERROR;
    sb->state = JBXL_NORMAL;
    if (mesg==NULL) return JBXL_ARGS_ERROR;
    if (sb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;
 
    len = (int)strlen((const char*)mesg);
    for (i=0, n=0, m=0; i<len; i++) {
        if (mesg[i]==CHAR_LF || (mesg[i]==CHAR_CR && mesg[i+1]!=CHAR_LF)) {
            if (m==0) m = i;
            n++;
        }
    }
    if (sb->datano==0 && n>=1) np = (sb->epoint + m + 1) % sb->bufsz;
 
    cc = put_ringBuffer(sb, mesg, len);
    if (cc>=0) {
        if (sb->datano==0 && n>=1) sb->npoint = np;
        sb->datano += n;
    }
 
    if (cc<0) sb->state = JBXL_ERROR;
    return cc;
}
 
 
unsigned char*  get_mstream(mstream* sb)
{
    int  n, len;
    unsigned char* pp;
 
    if (sb==NULL) return NULL;
    sb->state = JBXL_NORMAL;
    if (sb->buf==NULL) return NULL;
    if (sb->datano==0) return NULL;
 
    len = sb->npoint - sb->spoint;
    if (len==0) return NULL;
    else if (len<0) len += sb->bufsz;
 
    pp = get_ringBuffer(sb, len);
    if (pp==NULL) {
        sb->state = JBXL_ERROR;
        return NULL;
    }
    chomp((char*)pp);
 
    sb->datano += -1;
    sb->spoint = sb->npoint;
 
    if (sb->datano>=1) {
        int m;
        n = sb->spoint;
        while (n!=sb->epoint) {
            m = (n + 1) % sb->bufsz;
            if (sb->buf[n]==CHAR_LF || (sb->buf[n]==CHAR_CR && sb->buf[m]!=CHAR_LF)) {
                sb->npoint = m;
                break;
            }
            n = m;
        }
    }
 
    return pp;
}
 
 
unsigned char*  fgets_mstream(unsigned char* mesg, mstream* sb)
{
    int state = JBXL_NORMAL;
    unsigned char* pp;
 
    if (sb==NULL) return NULL;
    if (sb->buf==NULL) {
        *sb = make_mstream(RECVBUFSZ);
        if (sb->buf==NULL) return NULL;
    }
 
    if (mesg!=NULL) put_mstream(sb, mesg);
    if (sb->state<0) state = sb->state;
 
    if (sb->datano==0) {
        sb->state = JBXL_NODATA;
        return NULL;
    }
    pp = get_mstream(sb);
    
    if (sb->state>=0 && state<0) sb->state = state;
    return pp;
}
 
 
 
//
 
unsigned char*  uuid2guid(unsigned char* p)
{
    unsigned char* guid;
 
    if (p==NULL) return NULL;
 
    guid = (unsigned char*)malloc(LGUID);    // 40 = 32+4+1(\0) + α
    if (guid==NULL) return NULL;
    memset(guid, 0, LGUID);
 
    snprintf((char*)guid, 37, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                    p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
 
    return guid;
}
 
 
unsigned char*  guid2uuid(unsigned char* p)
{
    int   i, j;
    unsigned char* uuid;
 
    if (p==NULL) return NULL;
 
    uuid = (unsigned char*)malloc(16);
    if (uuid==NULL) return NULL;
    memset(uuid, 0, 16);
 
    i = j = 0;
    while (p[i]!='\0' && j<16) {
        if (p[i]!='-' && p[i+1]!='\0') {
            unsigned char hb, lb;
 
            if      (p[i]>='0' && p[i]<='9')     hb = p[i] - '0';
            else if (p[i]>='a' && p[i]<='f')     hb = p[i] - 'a' + 10;
            else if (p[i]>='A' && p[i]<='F')     hb = p[i] - 'A' + 10;
            else hb = '\0';
 
            if      (p[i+1]>='0' && p[i+1]<='9') lb = p[i+1] - '0';
            else if (p[i+1]>='a' && p[i+1]<='f') lb = p[i+1] - 'a' + 10;
            else if (p[i+1]>='A' && p[i+1]<='F') lb = p[i+1] - 'A' + 10;
            else lb = '\0';
            
            uuid[j] = (hb<<4) + lb;
            i++;
            j++;
        }
        i++;
    }
 
    return uuid;
}
 
 
 
//
 
#ifndef WIN32
 
unsigned long int get_used_memory(void)
{
    struct sysinfo info;
    sysinfo(&info);
 
    // キャッシュサイズが引けていない．
    unsigned long int mem = info.totalram - info.freeram - info.bufferram - info.sharedram;
    return mem*info.mem_unit/1024;
}
 
 
unsigned long int get_free_memory(void)
{
    struct sysinfo info;
    sysinfo(&info);
 
    unsigned long int mem = info.freeram;
    return mem*info.mem_unit/1024;
}
 
 
void  memory_check_start(void)
{
    UsedMemoryBase = get_used_memory();
}
 
 
unsigned long int  memory_check(void)
{
    return get_used_memory() - UsedMemoryBase;
}
 
 
#endif
 
 
 
// シグナル処理
//
#ifndef WIN32
 
#ifdef SIGCHLD
 
void  set_sigterm_child(void (*handler)(int))
{    
    struct sigaction sa;
 
    memset(&sa, 0, sizeof(sa));
    if (handler!=NULL) sa.sa_handler = handler;
    else               sa.sa_handler = sigterm_child;
 
    sa.sa_flags = SA_NOCLDSTOP | SA_RESTART; 
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, SIGINT);     // SIGCHLD 処理中は SIGINT  をブロック
    sigaddset(&sa.sa_mask, SIGHUP);     // SIGCHLD 処理中は SIGHUP  をブロック
    sigaddset(&sa.sa_mask, SIGTERM);    // SIGCHLD 処理中は SIGTERM をブロック
    sigaction(SIGCHLD, &sa, NULL);
}
 
 
void  sigterm_child(int signal)
{
    UNUSED(signal);
 
    pid_t pid = 0;
    int ret;
 
    //DEBUG_MODE PRINT_MESG("%d is waiting for children. signal = %d\n", getpid(), signal);
    //signal = 0;        // dummy for warning of compiler
 
    do {    // チャイルドプロセスの終了を待つ    
        pid = waitpid(-1, &ret, WNOHANG);
    } while(pid>0);
}
 
 
void  ignore_sigterm_child()
{    
    struct sigaction sa;
 
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = SIG_IGN;
    sa.sa_flags   = 0; 
    sigemptyset(&sa.sa_mask);
    sigaction(SIGCHLD, &sa, NULL);
}
 
 
void  set_sigsegv_handler(void (*handler)(int))
{
    struct sigaction sa;
 
    memset(&sa, 0, sizeof(sa));
    if (handler!=NULL) sa.sa_handler = handler;
    else               sa.sa_handler = trap_segmentation_falt;
    
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGSEGV, &sa, NULL);
}
 
 
void  trap_segmentation_falt(int signal)
{
    PRINT_MESG("****************************************************************\n");
    PRINT_MESG("* Segmentation Falt in [%d] !!!!!\n", getpid());
    PRINT_MESG("****************************************************************\n");
 
    exit(signal);
}
 
 
#endif        // SIGCHLD
 
#endif        // NOT WIN32
 
 
// for MS Windows
//
 
#ifdef WIN32
 
/* see common.h
 
void  bzero(char* p, unsigned int n)
{
    for (unsigned int i=0; i<n; i++) *(p++) = 0x00;
}
 
 
void  bcopy(char* f, char* t, unsigned int n)
{
    for (unsigned int i=0; i<n; i++) *(t++) = *(f++);
}
*/
 
#endif   // WIN32
 
 
 
// 入出力＆DEBUG
//
 
FILE*  FP_LogFile = NULL;
FILE*  FP_ErrFile = NULL;
 
 
void  open_logfile(void)
{
    if (FP_LogFile!=NULL) return;
 
    FP_LogFile = fopen(JBXL_LOG_FILE, "a");
    return;
}
 
 
void  close_logfile(void)
{
    if (FP_LogFile==NULL) return;
 
    fclose(FP_LogFile);
    FP_LogFile = NULL;
 
    return;
}
 
 
void  print_logfile(const char* fmt, ...)
{
    char*  nfmt;
    int    len;
    int    slfopn = FALSE;
 
    //
    if (FP_LogFile==NULL) {
        FP_LogFile = fopen(JBXL_LOG_FILE, "a");
        if (FP_LogFile==NULL) return;
        slfopn = TRUE;
    }
 
    va_list  args;
    va_start(args, fmt);
 
    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 2);
    if (nfmt==NULL) return;
 
    strncpy(nfmt, fmt, len);
    nfmt[len]   = '\n';
    nfmt[len+1] = '\0';
 
    vfprintf(FP_LogFile, nfmt, args); 
    fflush(FP_LogFile);
    free(nfmt);
 
    va_end(args);
 
    //
    if (slfopn && FP_LogFile!=NULL) {
        fclose(FP_LogFile);
        FP_LogFile = NULL;
    }
 
    return;
}
 
 
void  open_errfile(void)
{
    if (FP_ErrFile!=NULL) return;
 
    FP_LogFile = fopen(JBXL_ERR_FILE, "a");
    return;
}
 
 
void  close_errfile(void)
{
    if (FP_ErrFile==NULL) return;
 
    fclose(FP_ErrFile);
    FP_ErrFile = NULL;
 
    return;
}
 
 
void  print_errfile(const char* fmt, ...)
{
    char*  nfmt;
    int    len;
    int    slfopn = FALSE;
 
    //
    if (FP_ErrFile==NULL) {
        FP_ErrFile = fopen(JBXL_ERR_FILE, "a");
        if (FP_ErrFile==NULL) return;
        slfopn = TRUE;
    }
 
    va_list  args;
    va_start(args, fmt);
 
    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 2);
    if (nfmt==NULL) return;
 
    strncpy(nfmt, fmt, len);
    nfmt[len]   = '\n';
    nfmt[len+1] = '\0';
 
    vfprintf(FP_ErrFile, nfmt, args); 
    fflush(FP_ErrFile);
    free(nfmt);
 
    va_end(args);
 
    //
    if (slfopn && FP_ErrFile!=NULL) {
        fclose(FP_ErrFile);
        FP_ErrFile = NULL;
    }
 
    return;
}
 
 
void  print_message(const char* fmt, ...)
{
    char*  nfmt;
    int    len;
 
    va_list  args;
    va_start(args, fmt);
 
    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 1);
    if (nfmt==NULL) return;
 
    strncpy(nfmt, fmt, len);
    nfmt[len] = '\0';
 
    vfprintf(stderr, nfmt, args); 
    fflush(stderr);
    free(nfmt);
 
    va_end(args);
 
    return;
}
 
 
void  fprint_message(FILE* fp, const char* fmt, ...)
{
    char*  nfmt;
    int    len;
 
    va_list  args;
    va_start(args, fmt);
 
    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 1);
    if (nfmt==NULL) return;
 
    strncpy(nfmt, fmt, len);
    nfmt[len] = '\0';
 
    vfprintf(fp, nfmt, args); 
    fflush(fp);
    free(nfmt);
 
    va_end(args);
 
    return;
}
 
 
void  print_escape(const char* fmt, char* mesg)
{
    char* pp;
 
    if (fmt==NULL || mesg==NULL) return;
    
    pp = change_esc(mesg);
    if (pp==NULL) return;
 
    PRINT_MESG(fmt, pp);
    free(pp);
}
 
 
void  fprint_escape(FILE* fp, char* fmt, char* mesg)
{
    char* pp;
 
    if (fmt==NULL || mesg==NULL) return;
    
    pp = change_esc(mesg);
    if (pp==NULL) return;
 
    fprint_message(fp, fmt, pp);
    free(pp);
}
 
 
void  fdump(FILE* fp, unsigned char* mesg, int n)
{
    int  i, j, mod, len;
    char ascii[16];
 
    if (fp==NULL) fp = stderr;
 
    if (mesg==NULL) {
        fprintf(fp, "(Dump Data is NULL)\n");
        return;
    }
 
    if (n<0) len = (int)strlen((const char*)mesg);
    else     len = n;
 
    memset(ascii, 0x2e, 16);
    for (i=0, j=0; i<len; i++) {
        fprintf(fp, "%02x ", mesg[i]);
        if (mesg[i]>=0x20 && mesg[i]<=0x7e) ascii[j] = mesg[i];
        j++;
        if (j==16) {
            fprintf(fp, "   ");
            for (j=0; j<16; j++) {
                fprintf(fp, "%c ", ascii[j]);
            }
            fprintf(fp, "\n");
            memset(ascii, 0x2e, 16);
            j = 0;
        }
    }
                
    mod = len%16;
    if (mod>0) {                           
        for (i=0; i<17-mod; i++) fprintf(fp, "   ");
        for (i=0; i<mod; i++)    fprintf(fp, "%c ", ascii[i]);
    }                    
    fprintf(fp, "\n");
}
 
 
void  print_16x(FILE* fp, unsigned char* mesg, int n)
{
    int  i, len;
 
    if (fp==NULL) fp = stderr;
 
    if (n<0) len = (int)strlen((const char*)mesg);
    else     len = n;
 
    for (i=0; i<len; i++) {
        fprintf(fp, "%02x", mesg[i]);
    }
    fprintf(fp, "\n");
}
 
 
 
// グラフィック
//
 
static  char  _GraphicFileExtension[L_OCT];
 
char*    get_graphic_extension(uWord tex)
{
    memset(_GraphicFileExtension, 0, L_OCT);
 
    uWord file = tex & 0x00f0;
    if      (file==JBXL_TEXTURE_JPEG) memcpy(_GraphicFileExtension, ".jpeg", 5);
    else if (file==JBXL_TEXTURE_TIFF) memcpy(_GraphicFileExtension, ".tiff", 5);
    else if (file==JBXL_TEXTURE_PNG)  memcpy(_GraphicFileExtension, ".png",  4);
    else if (file==JBXL_TEXTURE_TGA)  memcpy(_GraphicFileExtension, ".tga",  4);
    else if (file==JBXL_TEXTURE_JP2K) memcpy(_GraphicFileExtension, ".jp2",  4);
    else if (file==JBXL_TEXTURE_RAS)  memcpy(_GraphicFileExtension, ".ras",  4);
 
    return _GraphicFileExtension;
}