buffer.cpp

Go to the documentation of this file.

 
#include "buffer.h"
#include "jbxl_state.h"
 
 
Buffer*  new_Buffer(int sz)
{
    Buffer*  buf;
 
    buf = (Buffer*)malloc(sizeof(Buffer));
    if (buf==NULL) return NULL;
 
    memset(buf, 0, sizeof(Buffer));
    buf->vldsz = -1;
    buf->state = JBXL_NORMAL;
 
    if (sz>0) *buf = make_Buffer(sz + 1);
    return buf;
}
Buffer*  new_Buffer(int sz) {…}
 
 
Buffer  init_Buffer()
{
    Buffer  buf;
 
    memset(&buf, 0, sizeof(Buffer));
    buf.vldsz = -1;
    buf.state = JBXL_NORMAL;
 
    return buf;
}
Buffer  init_Buffer() {…}
 
 
Buffer  make_Buffer(int sz)
{
    Buffer  buf;
 
    memset(&buf, 0, sizeof(Buffer));
    buf.state = JBXL_NORMAL;
    if (sz<0) return buf;
 
    buf.bufsz = sz;
    buf.buf = (unsigned char*)malloc(buf.bufsz+1);
 
    if (buf.buf==NULL) {
        buf.bufsz = 0;
        buf.vldsz = -1;
        buf.state = JBXL_ERROR;
    }
    else {
        memset(buf.buf, 0, buf.bufsz+1);
    }
 
    return buf;
}
Buffer  make_Buffer(int sz) {…}
 
 
Buffer  make_Buffer_bychar(unsigned char cc)
{
    Buffer  buf;
    
    buf = make_Buffer(LADDR);
    if (buf.buf==NULL) return buf;
 
    buf.buf[0] = cc;
    buf.vldsz = 1;
    return buf;
}
Buffer  make_Buffer_bychar(unsigned char cc) {…}
 
 
void  free_Buffer(Buffer* buf)
{
    if (buf!=NULL) {
        if (buf->buf!=NULL) free(buf->buf);
        buf->buf = NULL;
        memset(buf, 0, sizeof(Buffer));
        buf->vldsz = -1;
        buf->state = JBXL_NORMAL;
    }
}
void  free_Buffer(Buffer* buf) {…}
 
 
void   del_Buffer(Buffer** buf)
{
    if (buf!=NULL && *buf!=NULL) {
        if ((*buf)->buf!=NULL) free((*buf)->buf);
        (*buf)->buf = NULL;
        free(*buf);
        *buf = NULL;
    }
}
void   del_Buffer(Buffer** buf) {…}
 
 
Buffer  set_Buffer(void* dat, int len)
{
    Buffer  buf;
 
    buf = init_Buffer();
    if (dat==NULL) return buf;
 
    if (len<0) len = (int)strlen((char*)dat);
    buf = make_Buffer(len);
    if (buf.buf==NULL) return buf;
 
    memcpy(buf.buf, dat, len);
    buf.vldsz = len;
    return  buf;
}
Buffer  set_Buffer(void* dat, int len) {…}
 
 
Buffer  make_Buffer_randomstr(int n)
{
    char* str = random_str(n);
 
    Buffer buf = set_Buffer(str, -1);
    free(str);
 
    return buf;
}
Buffer  make_Buffer_randomstr(int n) {…}
 
 
Buffer  dup_Buffer(Buffer buf)
{
    Buffer  str = buf;
 
    if (buf.bufsz>=0 && buf.buf!=NULL) {
        str.buf = (unsigned char*)malloc(buf.bufsz+1);
        memcpy(str.buf, buf.buf, buf.bufsz);
        str.buf[buf.bufsz] = '\0';
    }
    //
    return  str;
}
Buffer  dup_Buffer(Buffer buf) {…}
 
 
Buffer  rept_Buffer(unsigned char cc, int n)
{
    int  i;
    Buffer  str;
    
    if (n<=0) n = 1;
    str = make_Buffer(n);
    for (i=0; i<n; i++) str.buf[i] = cc;
    str.vldsz = n;
    return  str;
}
Buffer  rept_Buffer(unsigned char cc, int n) {…}
 
 
void  expand_Buffer(Buffer* buf, int len)
{
    if (buf->bufsz>len) return;
 
    Buffer expand = make_Buffer(len);
    copy_Buffer(buf, &expand);
    free_Buffer(buf);
 
    *buf = expand;
}
void  expand_Buffer(Buffer* buf, int len) {…}
 
 
void  clear_Buffer(Buffer* str)
{
    if (str->buf!=NULL) memset(str->buf, 0, str->bufsz+1);
    str->vldsz = 0;
    str->state = JBXL_NORMAL;
}
void  clear_Buffer(Buffer* str) {…}
 
 
int  copy_Buffer(Buffer* src, Buffer* dst)
{
    int sz, dz;
 
    if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
    if (src->buf==NULL) return JBXL_NULL_ERROR;
 
    sz = src->vldsz;
    if (sz<0)  sz = (int)strlen((const char*)src->buf);
    if (sz==0) return 0;
 
    if (dst->bufsz < sz) {
        unsigned char* buf;
        //dz  = (int)((src->bufsz+1)*BUFFER_FACT);
        dz  = (int)((sz+1)*BUFFER_FACT);
        buf = (unsigned char*)malloc(dz+1);
        if (buf==NULL) return JBXL_MALLOC_ERROR;
        memset(buf, 0, dz+1);
 
        free(dst->buf);
        dst->bufsz = dz;
        dst->buf   = buf;
    }
 
    //memset(dst->buf, 0, dst->bufsz+1);        too late
    memcpy(dst->buf, src->buf, sz);
    dst->buf[sz] = '\0';
    dst->vldsz = sz;
 
    return  sz;
}
int  copy_Buffer(Buffer* src, Buffer* dst) {…}
 
 
int  cat_Buffer(Buffer* src, Buffer* dst)
{
    int sz, dz;
 
    if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
    if (src->buf==NULL) return JBXL_NULL_ERROR;
 
    sz = src->vldsz;
    if (sz<0) sz = (int)strlen((const char*)src->buf);
    if (sz==0) return 0;
 
    dz = dst->vldsz;
    if (dz<0) {
        if (dst->buf!=NULL) dz = (int)strlen((const char*)dst->buf);
        else                dz = 0;
    }
 
    if (dst->bufsz < sz+dz) {
        Buffer buf;
        buf.state = dst->state;
        buf.bufsz = (int)((dst->bufsz+sz+1)*BUFFER_FACT);
        buf.vldsz = dz;
        buf.buf   = (unsigned char*)malloc(buf.bufsz+1);
        if (buf.buf==NULL) return JBXL_MALLOC_ERROR;
   
        memcpy(buf.buf, dst->buf, dz);
        buf.buf[dz] = '\0';
        free_Buffer(dst);
        *dst = buf;
/*
        Buffer buf;                 // dstの待避 
        buf.bufsz = dst->bufsz;
        buf.vldsz = dz;
        buf.buf   = (unsigned char*)malloc(buf.bufsz+1);
        if (buf.buf==NULL) return JBXL_MALLOC_ERROR; 
 
        buf.buf[buf.bufsz] = '\0';
        memcpy(buf.buf, dst->buf, buf.bufsz);
        free_Buffer(dst);
 
        //dst->bufsz = (int)((buf.bufsz+src->bufsz+1)*BUFFER_FACT);
        dst->bufsz = (int)((buf.bufsz+sz+1)*BUFFER_FACT);
        dst->buf   = (unsigned char*)malloc(dst->bufsz+1);
        if (dst->buf==NULL) {
               *dst = buf;
               return JBXL_MALLOC_ERROR;
        }
        memset(dst->buf, 0, dst->bufsz+1);
        memcpy(dst->buf, buf.buf, buf.vldsz);
        free_Buffer(&buf);
*/
    }
 
    //memset(dst->buf+dz, 0, dst->bufsz-dz+1);  too late
    memcpy(dst->buf+dz, src->buf, sz);
    dst->buf[dz+sz] = '\0';
    dst->vldsz = sz + dz;
 
    return  dst->vldsz;
}
int  cat_Buffer(Buffer* src, Buffer* dst) {…}
 
 
int  ins_Buffer(Buffer* src, Buffer* dst)
{
    Buffer tmp = make_Buffer(src->bufsz + dst->bufsz);
 
    int ret = copy_Buffer(src, &tmp);
    if (ret<0) {
        free_Buffer(&tmp);
        return ret;
    }
 
    ret = cat_Buffer(dst, &tmp);
    if (ret<0) {
        free_Buffer(&tmp);
        return ret;
    }
 
    free_Buffer(dst);
    *dst = tmp;
 
    return  dst->vldsz;
}
int  ins_Buffer(Buffer* src, Buffer* dst) {…}
 
 
int  copy_b2Buffer(void* src, Buffer* dst, int len)
{
    int sz, dz;
 
    if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
    if (len<0) sz = (int)strlen((const char*)src);
    else       sz = len;
    if (sz<=0) return 0;
 
    if (dst->bufsz < sz) {
        unsigned char* buf;
        dz  = (int)((sz+1)*BUFFER_FACT);
        buf = (unsigned char*)malloc(dz+1);
        if (buf==NULL) return JBXL_MALLOC_ERROR;
        memset(buf, 0, dz+1);
 
        if (dst->buf!=NULL) free(dst->buf);
        dst->bufsz = dz;
        dst->buf   = buf;
    }
 
    memcpy(dst->buf, src, sz);
    dst->buf[sz] = '\0';
    dst->vldsz = sz;
    dst->state = JBXL_NORMAL;
 
    return  sz;
}
int  copy_b2Buffer(void* src, Buffer* dst, int len) {…}
 
 
int  cat_b2Buffer(void* src, Buffer* dst, int len)
{
    int sz, dz;
 
    if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
    if (len<0) sz = (int)strlen((const char*)src);
    else       sz = len;
    if (sz<=0) return 0;
   
    dz = dst->vldsz;
    if (dz<0) {
        if (dst->buf!=NULL) dz = (int)strlen((const char*)dst->buf);
        else                dz = 0;
    }
 
    if (dst->bufsz < sz+dz) {
        Buffer buf;
        buf.state = dst->state;
        buf.bufsz = (int)((dst->bufsz+sz+1)*BUFFER_FACT);
        buf.vldsz = dz;
        buf.buf   = (unsigned char*)malloc(buf.bufsz+1);
        if (buf.buf==NULL) return JBXL_MALLOC_ERROR;
    
        memcpy(buf.buf, dst->buf, dz);
        buf.buf[dz] = '\0';
        free_Buffer(dst);
        *dst = buf;    
    }
 
    memcpy(dst->buf+dz, src, sz);
    dst->buf[dz+sz] = '\0';
    dst->vldsz = sz + dz;
 
    return  dst->vldsz;
}
int  cat_b2Buffer(void* src, Buffer* dst, int len) {…}
 
 
int  ins_b2Buffer(void* src, Buffer* dst, int len)
{
    Buffer tmp = make_Buffer(dst->bufsz+len);
 
    int ret = copy_b2Buffer(src, &tmp, len);
    if (ret<0) {
        free_Buffer(&tmp);
        return ret;
    }
 
    ret = cat_Buffer(dst, &tmp);
    if (ret<0) {
        free_Buffer(&tmp);
        return ret;
    }
 
    free_Buffer(dst);
    *dst = tmp;
 
    return  dst->vldsz;
}
int  ins_b2Buffer(void* src, Buffer* dst, int len) {…}
 
 
int  copy_i2Buffer(int src, Buffer* dst)
{
    char num[LEN_INT];
 
    snprintf(num, LEN_INT-1, "%d", src);
    return copy_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  copy_i2Buffer(int src, Buffer* dst) {…}
 
 
int  cat_i2Buffer(int src, Buffer* dst)
{
    char num[LEN_INT];
 
    snprintf(num, LEN_INT-1, "%d", src);
    return cat_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  cat_i2Buffer(int src, Buffer* dst) {…}
 
 
int  ins_i2Buffer(int src, Buffer* dst)
{
    char num[LEN_INT];
 
    snprintf(num, LEN_INT-1, "%d", src);
    return ins_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  ins_i2Buffer(int src, Buffer* dst) {…}
 
 
int  copy_r2Buffer(float src, Buffer* dst)
{
    char num[LEN_REAL];
 
    snprintf(num, LEN_REAL-1, "%f", src);
    return copy_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  copy_r2Buffer(float src, Buffer* dst) {…}
 
 
int  cat_r2Buffer(float src, Buffer* dst)
{
    char num[LEN_REAL];
 
    snprintf(num, LEN_REAL-1, "%f", src);
    return cat_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  cat_r2Buffer(float src, Buffer* dst) {…}
 
 
int  ins_r2Buffer(float src, Buffer* dst)
{
    char num[LEN_REAL];
 
    snprintf(num, LEN_REAL-1, "%f", src);
    return ins_b2Buffer((void*)num, dst, (int)strlen(num));
}
int  ins_r2Buffer(float src, Buffer* dst) {…}
 
 
int  cmp_Buffer(Buffer src, Buffer dst, int n)
{
    int i;
 
    if (src.buf==NULL || dst.buf==NULL) return JBXL_NULL_ERROR;
    if (n>src.vldsz   || n>dst.vldsz)   return JBXL_BUFFER_CMP_ERROR;
    
    if (n<=0) {
        if (src.vldsz!=dst.vldsz) return 1;
        else n = src.vldsz;
    }
    
    for (i=0; i<n; i++) {
        if (src.buf[i]!=dst.buf[i]) return 1;
    }
    return 0;
}
int  cmp_Buffer(Buffer src, Buffer dst, int n) {…}
 
 
Buffer  encode_base64_Buffer(Buffer buf)
{
    unsigned char* bas;
    int     sz;
    Buffer ecd = init_Buffer();
     
    //
    if (buf.buf==NULL) return ecd;
    if (buf.vldsz<0) sz = (int)strlen((const char*)buf.buf);
    else             sz = buf.vldsz;
    if (sz<=0) return ecd;
 
    bas = encode_base64(buf.buf, sz);
    if (bas==NULL) return ecd;
    
    sz  = ((sz + 2)/3)*4 + 1;
    ecd = make_Buffer(sz);
    if (ecd.buf==NULL) {
        free(bas);
        return ecd;
    }
 
    copy_s2Buffer((char*)bas, &ecd);
 
    free(bas);
    return ecd;
}
Buffer  encode_base64_Buffer(Buffer buf) {…}
 
 
Buffer  decode_base64_Buffer(Buffer str)
{
    unsigned char* bas;
    int    sz;
    Buffer dcd = init_Buffer();
 
    if (str.buf==NULL) return dcd;
 
    bas = decode_base64(str.buf, &sz);
    if (bas==NULL) return dcd;
 
    dcd = make_Buffer(sz);
    if (dcd.buf==NULL) {
        free(bas);
        return dcd;
    }
 
    copy_b2Buffer(bas, &dcd, sz);
    dcd.vldsz = sz;
 
    free(bas);
    return dcd;
}
Buffer  decode_base64_Buffer(Buffer str) {…}
 
 
Buffer  encode_base64_Buffer_bin(unsigned char* bin, unsigned int sz, int nopad)
{
    unsigned char* str;
    Buffer enc = init_Buffer();
 
    if (bin==NULL) return enc;
    if (sz<=0) sz = (unsigned)strlen((char*)bin);
 
    str = encode_base64(bin, sz);
    if (str==NULL) return enc;
 
    if (nopad) {
        unsigned int len = (unsigned int)strlen((char*)str);
        if      (str[len-2]=='=') str[len-2] = '\0';
        else if (str[len-1]=='=') str[len-1] = '\0';
    }
    enc = make_Buffer_bystr(str);
    free(str);
 
    return enc;
}
Buffer  encode_base64_Buffer_bin(unsigned char* bin, unsigned int sz, int nopad) {…}
 
 
Buffer  encode_base64_filename_Buffer(Buffer buf, unsigned char cc)
{
    if (cc == 0x00) cc = '-';
 
    Buffer enc = encode_base64_Buffer(buf);
 
    int i;
    for (i=0; i<enc.vldsz; i++) {
       if (enc.buf[i]=='/') enc.buf[i] = cc;
    }
 
    return enc;
}
Buffer  encode_base64_filename_Buffer(Buffer buf, unsigned char cc) {…}
 
 
Buffer  decode_base64_filename_Buffer(Buffer str, unsigned char cc)
{
    if (cc == 0x00) cc = '-';
 
    int i;
    for (i=0; i<str.vldsz; i++) {
        if (str.buf[i]==cc) str.buf[i] = '/';
    }
 
    Buffer dec = decode_base64_Buffer(str);
 
    return dec;
}
Buffer  decode_base64_filename_Buffer(Buffer str, unsigned char cc) {…}
 
 
Buffer  get_line_Buffer(Buffer str, int n)
{
    int i, j, pos, cnt;
    unsigned char* buf;
 
    Buffer ret = init_Buffer();
    if (str.buf==NULL) return ret;
 
    buf = str.buf;
    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 ret;
 
    pos = i;
    while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
    cnt = i - pos;
 
    if (cnt>=0) {
        ret = make_Buffer(cnt+1);
        if (ret.buf==NULL) return str;
 
        for(i=0; i<cnt; i++) ret.buf[i] = buf[pos+i];
        ret.buf[cnt] = '\0';
    }
 
    ret.vldsz = (int)strlen((const char*)ret.buf);
 
    return  ret;
}
Buffer  get_line_Buffer(Buffer str, int n) {…}
 
 
Buffer  get_seq_data_Buffer(Buffer str, int* ptr)
{
    int   i, pos, cnt;
    unsigned char* buf;
 
    Buffer ret = init_Buffer();
 
    if (str.buf==NULL) return ret;
    if (str.vldsz<=0) str.vldsz = (int)strlen((const char*)str.buf);
    if (*ptr >= str.vldsz) return ret;
 
    buf = str.buf;
    pos = *ptr;
    while (buf[*ptr]!=CHAR_LF && buf[*ptr]!=CHAR_CR && buf[*ptr]!='\0') (*ptr)++;
    cnt = *ptr - pos;
 
    if (cnt>=0) {
        ret = make_Buffer(cnt+1);
        if (ret.buf==NULL) return ret;
 
        for(i=0; i<cnt; i++) ret.buf[i] = buf[pos+i];
        ret.buf[cnt] = '\0';
    }
 
    ret.vldsz = (int)strlen((const char*)ret.buf);
 
    // 空行
    while (buf[*ptr]==CHAR_LF || buf[*ptr]==CHAR_CR) (*ptr)++;
 
    return  ret;
}
Buffer  get_seq_data_Buffer(Buffer str, int* ptr) {…}
 
 
Buffer  awk_Buffer(Buffer str, char cc, int n)
{
    int i, j, pos, cnt;
    unsigned char* buf = str.buf;
    Buffer item = init_Buffer();
 
    if (buf==NULL) return item;
    if (n<=0) n = 1;
 
    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 item;
 
    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;
 
    item = make_Buffer(cnt);
    if (item.buf==NULL) return item;
 
    for (i=0; i<cnt; i++) item.buf[i] = buf[pos+i];
    item.vldsz = (int)strlen((const char*)item.buf);
 
    return item;
}
Buffer  awk_Buffer(Buffer str, char cc, int n) {…}
 
 
Buffer  cawk_Buffer(Buffer str, char cc, int n)
{
    int i, j, pos, cnt;
    unsigned char* buf = str.buf;
    Buffer item = init_Buffer();
 
    if (buf==NULL) return item;
    if (n<=0) n = 1;
 
    i = 0;
    for(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 item;
 
    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;
 
    item = make_Buffer(cnt);
    if (item.buf==NULL) return item;
 
    for (i=0; i<cnt; i++) item.buf[i] = buf[pos+i];
    item.vldsz = (int)strlen((const char*)item.buf);
 
    return item;
}
Buffer  cawk_Buffer(Buffer str, char cc, int n) {…}
 
 
Buffer  pack_Buffer(Buffer buf, char cc)
{
    Buffer res = init_Buffer();
 
    if (buf.buf==NULL) return res;
 
    res.buf = (unsigned char*)pack_char((char*)buf.buf, cc);
    res.vldsz = (int)strlen((char*)res.buf);
    res.bufsz = res.vldsz;
 
    return res;
}
Buffer  pack_Buffer(Buffer buf, char cc) {…}
 
 
void kanji_convert_Buffer(Buffer* str)
{
    int i; 
    unsigned char *c1, *c2;
 
    if (KanjiCode==CODE_SJIS) {
        i = 0;
        while(str->buf[i]!='\0'){
            c1 = &(str->buf[i]);
            c2 = c1 + 1;
            if(*c1>=0xa1 && *c1<=0xfe){
                euc2sjis(c1, c2);    
                i = i + 2;
            } 
            else  i++;
        }
    }              
    /*
    else if (KanjiCode==CODE_EUC) {
        i = 0;
        while(str->buf[i]!='\0'){
            c1 = (unsigned char) str->buf[i];
            c2 = (unsigned char) str->buf[i+1];
            if((c1>=0x81 && c1<=0x9f) || (c1>=0xe0 && c1<=0xff)) {
                sjis2euc(c1, c2);    
                i = i + 2;
            } 
            else  i++;
        }
    } 
    */             
}
void kanji_convert_Buffer(Buffer* str) {…}
 
 
Buffer  randstr_Buffer(int n)
{
    char   base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    Buffer pass;
    int    i, sz;
 
    pass = make_Buffer(n);
    if (pass.buf==NULL) return pass;
 
    sz = (int)strlen(base);
    for (i=0; i<n; i++) pass.buf[i] = base[rand()%sz];
    pass.vldsz = n;
 
    return pass;
}
Buffer  randstr_Buffer(int n) {…}
 
 
Buffer  randbit_Buffer(int n) 
{
    int   i, sz;
    Buffer str;
    
    sz = (n+7)/8;
    str = make_Buffer(sz);
    if (str.buf==NULL) return str;
    str.vldsz = sz;
 
    for (i=0; i<n; i++) setBit(str.buf, i, rand()%2);
    return str;     
}
Buffer  randbit_Buffer(int n)  {…}
 
 
#define  DUMP_BUFFER_LINE_SIZE     85     // 16*5("%02x "+"%c ") + 5("   "+"\r\n");
#define  DUMP_BUFFER_DELI_START    48     // 16*3("%02x ") 
#define  DUMP_BUFFER_CHAR_START    51     // 16*3("%02x ") + 3("   ") 
 
Buffer  dump_Buffer(Buffer buf)
{
    int    sz;
    char   wrkbuf[10];
    Buffer str = init_Buffer();
 
    if (buf.buf==NULL) return str;
    if (buf.vldsz<0) sz = (int)strlen((const char*)buf.buf) + 1;
    else             sz = buf.vldsz;
 
    int lineno = (sz + 15)/16;
    str = make_Buffer(lineno*DUMP_BUFFER_LINE_SIZE+1);
 
    int l;
    for (l=0; l<lineno; l++) {
        int sp = l*DUMP_BUFFER_LINE_SIZE;
        int i  = 0;
        while (i<16) {
            sprintf(wrkbuf, "%02x ", buf.buf[l*16+i]);
            memcpy(str.buf+sp+i*3, wrkbuf, 3);
 
            if (buf.buf[l*16+i]>=0x20 && buf.buf[l*16+i]<=0x7e) {
                sprintf(wrkbuf, "%c ", buf.buf[l*16+i]);
                memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, wrkbuf, 2);
            }
            else {
                memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, ". ", 2);
            }
 
            if (l*16+i>=sz) {
                memcpy(str.buf+sp+i*3, "   ", 3);
                memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, "  ", 2);
            }
 
            i++;
        }
        memcpy(str.buf+sp+DUMP_BUFFER_DELI_START, "   ", 3);
        str.buf[sp+DUMP_BUFFER_LINE_SIZE-2] = '\r';
        str.buf[sp+DUMP_BUFFER_LINE_SIZE-1] = '\n';
    }
    
    str.vldsz = lineno*DUMP_BUFFER_LINE_SIZE;
    return str;
}
Buffer  dump_Buffer(Buffer buf) {…}
 
 
int  recalc_strlen_Buffer(Buffer* buf)
{
    int len = (int)strlen((char*)buf->buf);
    buf->vldsz = len;
    return len;
}
int  recalc_strlen_Buffer(Buffer* buf) {…}
 
 
void    add_indent_Buffer(Buffer* buf, char cc, int len)
{
    char* indent = (char*)malloc(len + 1);
    if (indent!=NULL) {
        memset(indent, cc, len);
        indent[len] = '\0';
        cat_s2Buffer(indent, buf);
        free(indent);
    }
}
void    add_indent_Buffer(Buffer* buf, char cc, int len) {…}
 
 
void  chomp_Buffer(Buffer* str)
{
    int i, len;
    
    if (str->buf==NULL) return;
 
    len = (int)strlen((const char*)str->buf);
    for (i=0; i<len; i++) {
        if (str->buf[i]==CHAR_LF || str->buf[i]==CHAR_CR) {
            str->buf[i] = '\0';
            str->vldsz = (int)strlen((const char*)str->buf);
            return;
        }
    }
}
void  chomp_Buffer(Buffer* str) {…}
 
 
int  isText_Buffer(Buffer buf)
{
    int i;
    for (i=0; i<buf.vldsz; i++) {
        if (buf.buf[i]<0x20 && buf.buf[i]!=0x0a && buf.buf[i]!=0x0d 
                            && buf.buf[i]!=0x00 && buf.buf[i]!=0x09) return FALSE;
        if (buf.buf[i]==0x7f) return FALSE; // DEL
    }
 
    //if (buf.vldsz==(int)strlen((const char*)buf.buf)) return TRUE;
    return FALSE;
}
int  isText_Buffer(Buffer buf) {…}
 
 
 
// File I/O
// 
 
int  fgets_Buffer(Buffer* str, FILE* fp)
{
    char* p;
    int   n, m;
    UNUSED(p);
 
    memset(str->buf, 0, str->bufsz);
    p = fgets((char*)str->buf, str->bufsz, fp);
    m = (int)strlen((const char*)str->buf);
 
    n = 0;
    while(str->buf[n]!=CHAR_LF && str->buf[n]!=CHAR_CR && str->buf[n]!='\0') n++;
    str->buf[n] = '\0';
    str->vldsz  = n;
 
//    if (KanjiCode!=US) kanji_convert_Buffer(str);
 
    return m;
}
int  fgets_Buffer(Buffer* str, FILE* fp) {…}
 
 
int  read_lines_Buffer(Buffer* str, FILE* fp)
{
    Buffer buf;
    char* pp;
    UNUSED(pp);
 
    buf = make_Buffer(str->bufsz);
    if (buf.buf==NULL) return JBXL_BUFFER_MAKE_ERROR;
 
    pp = fgets((char*)buf.buf, buf.bufsz, fp);
    buf.vldsz = (int)strlen((const char*)buf.buf);
    copy_Buffer(&buf, str);
    clear_Buffer(&buf);
 
    while (!feof(fp)) {
        pp = fgets((char*)buf.buf, buf.bufsz, fp);
        buf.vldsz = (int)strlen((const char*)buf.buf);
        cat_Buffer(&buf, str);
        clear_Buffer(&buf);
    }
 
    free_Buffer(&buf);
    return str->vldsz;
}
int  read_lines_Buffer(Buffer* str, FILE* fp) {…}
 
 
Buffer  read_Buffer_file(const char* fn)
{
    int     sz;
    Buffer  buf;
    FILE*   fp;
 
    buf = init_Buffer();
 
    sz = file_size(fn);
    if (sz<=0) return buf;
 
    fp = fopen(fn, "rb");
    if (fp==NULL) return buf;
 
    buf = read_Buffer_data(fp, sz);
    fclose(fp);
    
    return buf;
}
Buffer  read_Buffer_file(const char* fn) {…}
 
 
Buffer  read_Buffer_data(FILE* fp, int sz)
{
    int     cc;
    Buffer  buf;
 
    buf = init_Buffer();
    if (sz<0) return buf;
 
    buf = make_Buffer(sz);
    if (buf.buf==NULL) return buf;
    buf.vldsz = sz;
 
    cc = (int)fread(buf.buf, buf.vldsz, 1, fp);
    if (cc!=1) {
        free_Buffer(&buf);
        return buf;
    }
    
    return buf;
}
Buffer  read_Buffer_data(FILE* fp, int sz) {…}
 
 
int   save_Buffer_file(Buffer buf, char* fn)
{
    int   cc;
    FILE* fp;
 
    fp = fopen(fn, "wb");
    if (fp==NULL) return FALSE;
 
    cc = (int)fwrite(buf.buf, buf.vldsz, 1, fp);
    if (cc!=1) return FALSE;
    fclose(fp);
    
    return TRUE;
}
int   save_Buffer_file(Buffer buf, char* fn) {…}
 
 
 
//  文字列操作
// 
 
Buffer  erase_bBuffer(Buffer buf, char* bin, int len)
{
    int     i, j, n;
    char cc;
 
    Buffer res = dup_Buffer(buf);
    if (bin==NULL) return res;
    Buffer wrk = make_Buffer(buf.vldsz + 1);
 
    if (len<0) len = (int)strlen(bin);
    for (i=0; i<len; i++) {
        cc = bin[i];
        n  = 0;
        for (j=0; j<res.vldsz; j++) {
            if (cc!=res.buf[j]) wrk.buf[n++] = res.buf[j];
        }
        wrk.vldsz = n;
 
        copy_Buffer(&wrk, &res);
        clear_Buffer(&wrk);
    }
                
    free_Buffer(&wrk);
 
    return res;
}
Buffer  erase_bBuffer(Buffer buf, char* bin, int len) {…}
 
 
Buffer  replace_sBuffer_bystr(Buffer buf, const char* frm, const char* tos)
{
    int    i, j, flen, tlen;
    Buffer res;
 
    res = init_Buffer();
    if (buf.buf==NULL || frm==NULL || tos==NULL) return res;
 
    flen = (int)strlen(frm);
    tlen = (int)strlen(tos);
    if (buf.vldsz<=0) buf.vldsz = (int)strlen((const char*)buf.buf);
 
    int difsz = tlen - flen;
    if (difsz<0) difsz = 0;
    else         difsz = difsz*100;    // 100個まで
    res = make_Buffer((int)((buf.vldsz+difsz+1)*BUFFER_FACT));
 
    i = j = 0;
    while (i<buf.vldsz && j<res.bufsz) {
        if (!strncmp((const char*)(buf.buf+i), frm, flen)){
            res.vldsz = (int)strlen((const char*)res.buf);
            cat_s2Buffer(tos, &res);
            i += flen;
            j += tlen;
        }
        else {
            res.buf[j++] = buf.buf[i++];
        }
    }
 
    if (j==res.bufsz) res.state = JBXL_ERROR;
    res.vldsz = (int)strlen((const char*)res.buf);
 
    return res;
}
Buffer  replace_sBuffer_bystr(Buffer buf, const char* frm, const char* tos) {…}
 
 
int  replace_sBuffer_file(char* fn, Buffer frm, Buffer tos)
{
    int  ret;
    Buffer buf, res;
 
    buf = read_Buffer_file(fn);
    if (buf.buf==NULL) return FALSE;
 
    res = replace_sBuffer(buf, (char*)frm.buf, (char*)tos.buf);
    free_Buffer(&buf);
    if (res.buf==NULL) return FALSE;
 
    ret = save_Buffer_file(res, fn);
    free_Buffer(&buf);
 
    return ret;
}
int  replace_sBuffer_file(char* fn, Buffer frm, Buffer tos) {…}
 
 
void  rewrite_sBuffer_bystr(Buffer* buf, const char* frm, const char* tos)
{
    if (buf==NULL || frm==NULL || tos==NULL) return;
 
    Buffer tmp = replace_sBuffer_bystr(*buf, frm, tos);
    if (tmp.state==JBXL_NORMAL) {
        free_Buffer(buf);
        *buf = tmp;
    }
    return;
}
void  rewrite_sBuffer_bystr(Buffer* buf, const char* frm, const char* tos) {…}
 
 
void  rewrite_Buffer_bychar(Buffer* buf, const char frm, const char toc)
{
    if (buf==NULL) return;
 
    int i;
    for (i=0; i<buf->vldsz; i++) {
        if (buf->buf[i]==frm) buf->buf[i] = toc;
    }
    return;
}
void  rewrite_Buffer_bychar(Buffer* buf, const char frm, const char toc) {…}
 
 
 
//  ヘッダ（書式）付特殊ファイルI/O
// 
 
int   save_Buffer2_format_fp(Buffer key, Buffer buf, FILE* fp)
{
    int   cc;
    
    cc = save_Buffer_format_fp(key, fp);
    if (!cc) return FALSE;
 
    cc = save_Buffer_format_fp(buf, fp);
    if (!cc) return FALSE;
    
    return TRUE;
}
int   save_Buffer2_format_fp(Buffer key, Buffer buf, FILE* fp) {…}
 
 
int   save_Buffer_format_fp(Buffer buf, FILE* fp)
{
    int   cc, sz;
 
    sz = htonl(buf.vldsz);
    cc = (int)fwrite(&sz, sizeof(sz), 1, fp);
    if (cc!=1) return FALSE;
 
    cc = (int)fwrite(buf.buf, buf.vldsz, 1, fp);
    if (cc!=1) return FALSE;
    
    return TRUE;
}
int   save_Buffer_format_fp(Buffer buf, FILE* fp) {…}
 
 
Buffer  read_Buffer_format_fp(FILE* fp)
{
    int     cc, sz;
    Buffer  buf;
 
    buf = init_Buffer();
    cc = (int)fread(&sz, sizeof(sz), 1, fp);
    if (cc!=1) return buf;
    sz = ntohl(sz);
 
    buf = make_Buffer(sz);
    if (buf.buf==NULL) return buf;
    buf.vldsz = sz;
    cc = (int)fread(buf.buf, buf.vldsz, 1, fp);
    if (cc!=1) {
        free_Buffer(&buf);
        return buf;
    }
    
    return buf;
}
Buffer  read_Buffer_format_fp(FILE* fp) {…}
 
 
int  read_Buffer2_format_fp(Buffer* key, Buffer* buf, FILE* fp)
{
    if (key==NULL || buf==NULL) return FALSE;
 
    *key = init_Buffer();
    *buf = init_Buffer();
    
    *key = read_Buffer_format_fp(fp);
    if (key->buf==NULL) return FALSE;
 
    *buf = read_Buffer_format_fp(fp);
    if (buf->buf==NULL) {
        free_Buffer(key);
        return FALSE;
    }
 
    return TRUE;
}
int  read_Buffer2_format_fp(Buffer* key, Buffer* buf, FILE* fp) {…}
 
 
 
// etc. etc.
//
 
//
// get_char_ringbuffer() -> pop_char_ringStack()
// put_char_ringbuffer() -> push_char_ringStack()
//
 
 
char  pop_char_ringStack(Buffer* buf)
{
    buf->vldsz--;
    if (buf->vldsz<0) buf->vldsz = buf->bufsz - 1;
 
    return  (char)buf->buf[buf->vldsz];
}
char  pop_char_ringStack(Buffer* buf) {…}
 
 
void  push_char_ringStack(Buffer* buf, char cc)
{
    buf->buf[buf->vldsz] = (unsigned char)cc;
    buf->vldsz++;
    if (buf->vldsz==buf->bufsz) buf->vldsz = 0;
 
    return;
}
void  push_char_ringStack(Buffer* buf, char cc) {…}