tlist.cpp

Go to the documentation of this file.

 
#include  "tlist.h"
#include  "jbxl_state.h"
 
 
// List Data
//     静的に生成される． 
//
 
tList_data  init_tList_data(void)
{
    tList_data pp;
 
    memset(&pp, 0, sizeof(tList_data));
    return pp;
}
 
 
tList_data  make_tList_data(int id, int lv, Buffer key, Buffer val, void* ptr, int sz)
{
    tList_data pp;
 
    memset(&pp, 0, sizeof(tList_data));
 
    pp.id  = id;
    pp.lv  = lv;
    pp.sz  = sz;
    pp.key = dup_Buffer(key);    
    pp.val = dup_Buffer(val);
 
    if (sz>0) {
        pp.ptr = (void*)malloc(sz);
        if (pp.ptr!=NULL) {
            if (ptr!=NULL) memcpy(pp.ptr, ptr, sz);
            else           memset(pp.ptr, 0,   sz);
        }
    }
    
    return pp;
}
 
 
tList_data  make_tList_data_bystr(int id, int lv, const char* key, const char* val, void* ptr, int sz)
{
    tList_data pp;
    
    memset(&pp, 0, sizeof(tList_data));
 
    pp.id  = id;
    pp.lv  = lv;
    pp.sz  = sz;
    pp.key = make_Buffer_bystr(key);    // key==NULLなら init_Buffer()
    pp.val = make_Buffer_bystr(val);
 
    if (sz>0) {
        pp.ptr = (void*)malloc(sz);
        if (pp.ptr!=NULL) {
            if (ptr!=NULL) memcpy(pp.ptr, ptr, sz);
            else           memset(pp.ptr, 0,   sz);
        }
    }
 
    return pp;
}
 
 
void  clear_tList_data(tList_data* ldat)
{
    if (ldat==NULL) return;
 
    ldat->id = 0;
    ldat->lv = 0;
    ldat->sz = 0;
 
    free_Buffer(&(ldat->key));    
    free_Buffer(&(ldat->val));
    if (ldat->ptr!=NULL) free(ldat->ptr);
    del_all_tList(&(ldat->lst));
 
    ldat->key = init_Buffer();
    ldat->val = init_Buffer();
    ldat->ptr = NULL;
    ldat->lst = NULL;
 
    return;
}
 
 
void  del_tList_data(tList_data** ldat)
{
    if (ldat==NULL || *ldat==NULL) return;
 
    clear_tList_data(*ldat);
    *ldat = NULL;
 
    return;
}
 
 
tList_data  dup_tList_data(tList_data ldat)
{
    tList_data dup;    
 
    memcpy(&dup, &ldat, sizeof(tList_data));
    dup.key = dup_Buffer(ldat.key);
    dup.val = dup_Buffer(ldat.val);
    if (ldat.ptr!=NULL && ldat.sz>0) {
        dup.ptr = (void*)malloc(ldat.sz);
        if (dup.ptr!=NULL) memcpy(dup.ptr, ldat.ptr, ldat.sz);
    }
    dup.lst = dup_tList(ldat.lst);
    
    return dup;
}
 
 
 
// Tiny List
//
 
tList*  new_tList_node(void)
{
    tList* pp;
 
    pp = (tList*)malloc(sizeof(tList));
    if (pp==NULL) return NULL;
    memset(pp, 0, sizeof(tList));
    pp->ldat  = init_tList_data();
    pp->state = JBXL_NORMAL;
 
    return pp;
}
 
 
tList  make_tList_node(tList_data ldat)
{
    tList pp;
 
    memset(&pp, 0, sizeof(tList));
    pp.ldat  = ldat;    
    pp.state = JBXL_NORMAL;
 
    return pp;
}
 
 
tList*  free_tList_node(tList* node) 
{    
    if (node==NULL) return NULL;
 
    clear_tList_data(&(node->ldat));
 
    tList* pp = NULL;
    if (node->prev!=NULL) node->prev->next = node->next;
    if (node->next!=NULL) {
        node->next->prev = node->prev;
        pp = node->next;
    }
 
    return pp;
}
 
 
tList*  del_tList_node(tList** node)
{
    if (node==NULL || *node==NULL) return NULL;
 
    tList* pp = free_tList_node(*node);
    free(*node);
    *node = NULL;
 
    return pp;
}    
 
 
tList*  dup_tList_node(tList* node)
{
    tList* pp;
    int  sz;
 
    if (node==NULL) return NULL;
 
    sz = sizeof(tList);
    pp = (tList*)malloc(sz);
    if (pp==NULL) return NULL;
 
    memcpy(pp, node, sz);
    pp->ldat = dup_tList_data(node->ldat);
    pp->next = NULL;
    pp->prev = NULL;
    pp->altp = NULL;
    pp->yngr = NULL;
    pp->esis = NULL;
    pp->ysis = NULL;
 
    return pp;
}
 
 
tList*  move_tList_node(tList* pp, tList* node)
{
    if (pp==NULL || node==NULL) return NULL;
    
    if (node->prev!=NULL) node->prev->next = node->next;
    if (node->next!=NULL) node->next->prev = node->prev;
 
    node->prev = pp;
    node->next = pp->next;
    if (pp->next!=NULL) pp->next->prev = node;
    pp->next   = node;
    
    return node;
}
 
 
tList*  swap_tList_node(tList* pp1, tList* pp2)
{
    if (pp1==NULL || pp2==NULL) return NULL;
 
    tList_data swp = pp1->ldat;
    pp1->ldat = pp2->ldat;
    pp2->ldat = swp;
 
    return pp1;
/*
    if (*pp1==NULL || *pp2==NULL) return NULL;
 
    tList* p1 = dup_tList_node(*pp1);
    tList* p2 = dup_tList_node(*pp2);
 
    insert_tList(*pp1, p2);
    insert_tList(*pp2, p1);
 
    del_tList_node(pp1);
    del_tList_node(pp2);
 
    *pp1 = p2;
    *pp2 = p1;
 
    return p2;
*/
}
 
 
tList*  new_tList_anchor_node(void)
{
    tList* pp;
 
    pp = (tList*)malloc(sizeof(tList));
    if (pp==NULL) return NULL;
    memset(pp, 0, sizeof(tList));
    pp->ldat    = init_tList_data();
    pp->ldat.id = TLIST_ANCHOR_NODE;
    pp->depth   = -1;
    pp->state   = JBXL_STATE_ANCHOR;    // TLIST_ANCHOR_NODE と同じ
 
    return pp;
}
 
 
tList*  del_tList_anchor_node(tList* node)
{
    tList* pp = node;
 
    if (node!=NULL && node->ldat.id==TLIST_ANCHOR_NODE) {
        pp = node->next;
        free_tList_node(node);
        free(node);
    }
 
    return pp;
}
 
 
 
 
tList*  add_tList_node_bydata(tList* pp, tList_data ldat) 
{
    tList* pt;
 
    pt = new_tList_node();
    pt->ldat = ldat;
 
    if (pp==NULL) {
        return pt;
    }
    //
    if (pp->next==NULL) {
        pt->next = NULL;
        pt->prev = pp;
        pp->next = pt;
        return pt;
    }
 
    pt->next = pp->next;
    pt->prev = pp;
    pp->next = pt;
    pt->next->prev = pt;
 
    return pt;
}
 
 
tList*  add_tList_node_bystr(tList* pp, int id, int lv, const char* key, const char* val, void* ptr, int sz) 
{
    tList* pt;
    tList_data ldat;
 
    ldat = make_tList_data_bystr(id, lv, key, val, ptr, sz);
    pt   = add_tList_node_bydata(pp, ldat);
 
    return pt;
}
 
 
tList*  add_tList_node_byBuffer(tList* pp, int id, int lv, Buffer key, Buffer val, void* ptr, int sz) 
{
    tList* pt;
    tList_data ldat;
 
    ldat = make_tList_data(id, lv, key, val, ptr, sz);
    pt   = add_tList_node_bydata(pp, ldat);
 
    return pt;
}
 
 
void  set_tList_node_bydata(tList* node, tList_data dat)
{
    if (node==NULL) return;
 
    clear_tList_data(&(node->ldat));
    node->ldat = dat;
}
 
 
void  set_tList_node_bystr(tList* pp, int id, int lv, const char* key, const char* val, void* ptr, int sz)
{
    if (pp==NULL) return;
 
    pp->ldat.id = id;
    pp->ldat.lv = lv;
    pp->ldat.sz = sz;
 
    if (key!=NULL) {
        free_Buffer(&(pp->ldat.key));
        pp->ldat.key = make_Buffer_bystr(key);
    }
    if (val!=NULL) {
        free_Buffer(&(pp->ldat.val));
        pp->ldat.val = make_Buffer_bystr(val);
    }
 
    if (sz>0 && ptr!=NULL) {
        if (pp->ldat.ptr!=NULL) free(pp->ldat.ptr);
        pp->ldat.ptr = (void*)malloc(sz);
        if (pp->ldat.ptr!=NULL) memcpy(pp->ldat.ptr, ptr, sz);
    }
}
 
 
void  set_tList_node_byBuffer(tList* pp, int id, int lv, Buffer key, Buffer val, void* ptr, int sz)
{
    if (pp==NULL) return;
 
    pp->ldat.id = id;
    pp->ldat.lv = lv;
 
    if (pp->ldat.key.buf!=NULL) {
        free_Buffer(&(pp->ldat.key));
        pp->ldat.key = dup_Buffer(key);
    }
 
    if (pp->ldat.val.buf!=NULL) {
        free_Buffer(&(pp->ldat.val));
        pp->ldat.val = dup_Buffer(val);
    }
 
    if (sz>0 && ptr!=NULL) {
        if (pp->ldat.ptr!=NULL) free(pp->ldat.ptr);
        pp->ldat.ptr = (void*)malloc(sz);
        if (pp->ldat.ptr!=NULL) memcpy(pp->ldat.ptr, ptr, sz);
    }
}
 
 
tList*  update_tList_node(tList* pp, tList* pt)
{
    tList* pm;
    tList_data ldat;
 
    if (pt==NULL) return pp;
    
    ldat = pp->ldat;
    pm = update_tList_node_byBuffer(pp, ldat.id, ldat.lv, ldat.key, ldat.val, ldat.ptr, ldat.sz);
    
    return pm;
}
 
 
tList*  update_tList_node_bydata(tList* pp, char* srch, tList_data ldat)
{
    tList* pm = NULL;
 
    if (pp==NULL || srch==NULL) return NULL;
 
    pm = strncmp_tList(pp, srch, 0, 1);
    if (pm!=NULL) set_tList_node_bydata(pm, ldat);
    else {
        pm = find_tList_end(pp);
        pm = add_tList_node_bydata(pm, ldat);
    }
    
    return pm;
}
 
 
tList*  update_tList_node_bystr(tList* pp, int id, int lv, const char* key, const char* val, void* ptr, int sz)
{
    tList* pm = NULL;
 
    if (pp==NULL || key==NULL) return NULL;
 
    pm = strncmp_tList(pp, key, 0, 1);
    if (pm!=NULL) {
        set_tList_node_bystr(pm, id, lv, NULL, val, ptr, sz);
    }
    else {
        pm = find_tList_end(pp);
        pm = add_tList_node_bystr(pm, id, lv, key, val, ptr, sz);
    }
    
    return pm;
}
 
 
tList*  update_tList_node_byBuffer(tList* pp, int id, int lv, Buffer key, Buffer val, void* ptr, int sz)
{
    tList* pm = NULL;
 
    if (pp==NULL || key.buf==NULL) return NULL;
 
    pm = strncmp_tList(pp, (char*)key.buf, 0, 1);
    if (pm!=NULL) set_tList_node_byBuffer(pm, id, lv, key, val, ptr, sz);
    else {
        pm = find_tList_end(pp);
        pm = add_tList_node_byBuffer(pm, id, lv, key, val, ptr, sz);
    }
    
    return pm;
}
 
 
 
// tiny List
//
 
tList*  del_tList(tList** pp) 
{    
    tList* pt;
    tList* pm;
    tList* pw;
 
    if (pp==NULL || *pp==NULL) return NULL;
 
    pt = (*pp)->prev;
    if (pt!=NULL) pt->next = NULL;
 
    pm = *pp;
    while (pm!=NULL) {
        pw = pm;
        pm = pm->next;
        clear_tList_data(&(pw->ldat));
        free(pw);
    }
    *pp = NULL;
 
    return pt;
}
 
 
void  del_all_tList(tList** pp)
{
    tList* pm;
    tList* pv;
 
    if (pp==NULL || *pp==NULL) return;
 
    pm = *pp;
    pv = (*pp)->prev;
 
    do {
        pm = del_tList_node(&pm);
    } while (pm!=NULL);
 
    pm = pv;
    while (pm!=NULL) {
        pv = pm->prev;
        del_tList_node(&pm);
        pm = pv;
    }
 
    *pp = NULL;
}
 
 
int  del_tList_key(tList** pl, const char* key, int no)
{       
    int dl = 0;
    int nn = 0;
    if (no<0) no = 0;
 
    tList* pp = *pl;
 
    while (pp!=NULL) {
        if (ex_strncasecmp((char*)(pp->ldat).key.buf, key, 0)) {
            nn++;
            if (no==0 || no==nn) {
                if (pp->prev==NULL) *pl = pp->next;
                pp = del_tList_node(&pp);    
                dl++;
                if (no!=0) break;
            }
            else {
                pp = pp->next;
            }
        }
        else {
            pp = pp->next;
        }
    }
 
    return dl;
}
 
 
tList*  dup_tList(tList* pp)
{
    tList* pt;
    tList* pl;
    tList* tt;
 
    if (pp==NULL) return NULL;
 
    pt = pl = dup_tList_node(pp);
    pp = pp->next;
 
    while(pp!=NULL) {
        tt = dup_tList_node(pp);
        pl = insert_tList(pl, tt);
        pp = pp->next;
    }
 
    return pt;
}
 
 
tList*  add_tList_end(tList* pp, tList* pt)
{
    if (pt==NULL) return pp;
    if (pp==NULL) return pt;
 
    tList* pe = find_tList_end(pp);
    pe->next = pt;
    pt->prev = pe;
 
    return pp;
}
 
 
tList*  insert_tList(tList* pp, tList* pt)
{
    tList* pe;
    
    if (pt==NULL) return pp;
    if (pp==NULL) return pt;
 
    pe = find_tList_end(pt);
    if (pp->next!=NULL) pp->next->prev = pe;
    pe->next = pp->next;
    pp->next = pt;
    pt->prev = pp;
    
    return pt;
}
 
 
void  print_tList(FILE* fp, tList* pp)
{
    if (fp==NULL) fp = stderr;
 
    if (pp!=NULL) {
        while(pp!=NULL) {
            tList_data ld = pp->ldat;
            fprintf(fp, "[%d] [%d] [%s] [%s]\n", ld.id, ld.lv, ld.key.buf, ld.val.buf);
            //if (pp->next!=NULL) print_tList(pp->next);
            pp = pp->next;
        }
    }
    else {
        fprintf(fp, "(List is NULL)\n");
    }
    return;
}
 
 
void  dump_tList(FILE* fp, tList* pp)
{
    if (fp==NULL) fp = stderr;
 
    if (pp!=NULL) {
        while(pp!=NULL) {
            tList_data ld = pp->ldat;
            fprintf(fp, "[%d] [%d] [%s] [%d]\n", ld.id, ld.lv, ld.key.buf, ld.val.vldsz);
            fdump(fp, (unsigned char*)ld.val.buf, ld.val.vldsz);
            pp = pp->next;
        }
    }
    else {
        fprintf(fp, "(List is NULL)\n");
    }
    return;
}
 
 
int  count_tList(tList* pp)
{
    int cnt = 0;
 
    while (pp!=NULL) {
        cnt++;
        pp = pp->next;
    }    
    return cnt;
}
 
 
 
 
tList*  find_tList_top(tList* pl)
{
    if (pl==NULL) return NULL;
 
    while (pl->prev!=NULL) pl = pl->prev;
    return pl;
}
 
 
tList*  find_tList_end(tList* pl)
{
    if (pl==NULL) return NULL;
 
    while (pl->next!=NULL) pl = pl->next;
    return pl;
}
 
 
 
// String Compare
//
 
tList*  strncmp_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (ex_strncmp((char*)pl->ldat.key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  strncasecmp_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (ex_strncasecmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  strnrvscmp_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (ex_strnrvscmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  strncaservscmp_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (ex_strncaservscmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  strstr_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (len>=0) {
            if (strstr((char*)(pl->ldat).key.buf, key)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
        else if (len<0) {
            if (strstr(key, (char*)(pl->ldat).key.buf)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
 
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  strstrcase_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (len>=0) {
            if (strstrcase((char*)(pl->ldat).key.buf, key)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
        else if (len<0) {
            if (strstrcase(key, (char*)(pl->ldat).key.buf)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
 
        pl = pl->next;
    }
    return NULL;
}
 
 
 
// String Compare Back List
//
 
tList*  strncmp_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
    
    while (pl!=NULL) {
        if (ex_strncmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->prev;
    }
    return NULL;
}
 
 
tList*  strncasecmp_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
 
    while (pl!=NULL) {
        if (ex_strncasecmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->prev;
    }
    return NULL;
}
 
 
tList*  strnrvscmp_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
 
    while (pl!=NULL) {
        if (ex_strnrvscmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->prev;
    }
    return NULL;
}
 
 
tList*  strncaservscmp_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (len<=-3) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
 
    while (pl!=NULL) {
        if (ex_strncaservscmp((char*)(pl->ldat).key.buf, key, len)) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->prev;
    }
    return NULL;
}
 
 
tList*  strstr_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
 
    while (pl!=NULL) {
        if (len>=0) {
            if (strstr((char*)(pl->ldat).key.buf, key)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
        else if (len<0) {
            if (strstr(key, (char*)(pl->ldat).key.buf)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
 
        pl = pl->prev;
    }
    return NULL;
}
 
 
tList*  strstrcase_back_tList(tList* pl, const char* key, int len, int no)
{
    int nn = 0;
 
    if (pl==NULL || key==NULL) return NULL;
    if (no<=0) no = 1;
 
    pl = find_tList_end(pl);
 
    while (pl!=NULL) {
        if (len>=0) {
            if (strstrcase((char*)(pl->ldat).key.buf, key)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
        else if (len<0) {
            if (strstrcase(key, (char*)(pl->ldat).key.buf)!=NULL) {
                nn++;
                if (no==nn) return pl;
            }
        }
 
        pl = pl->prev;
    }
    return NULL;
}
 
 
 
 
tList*  search_id_tList(tList* pl, int id, int no) 
{
    int nn = 0;
 
    if (pl==NULL) return NULL;
    if (no<=0) no = 1;
 
    while (pl!=NULL) {
        if (pl->ldat.id == id) {
            nn++;
            if (no==nn) return pl;
        }
        pl = pl->next;
    }
    return NULL;
}
 
 
tList*  search_key_tList(tList* pl, const char* key, int no) 
{
    tList* pp;
    if (pl==NULL || key==NULL) return NULL;
    if (no<=0) no = 1;
    
    pp = strncasecmp_tList(pl, key, 0, no);        // 完全一致
    
    return pp;
}
 
 
Buffer  buffer_key_tList(tList* list, const char* key, int no) 
{
    tList* pp;
    Buffer buf;
 
    buf = init_Buffer();
    if (list==NULL || key==NULL) return buf;
    if (no<=0) no = 1;
    
    pp = strncasecmp_tList(list, key, 0, no);        // 完全一致
    if (pp!=NULL) {
        buf = dup_Buffer(pp->ldat.val);
    }
    
    return buf;
}
 
 
Buffer  buffer_key_value_tList(tList* list, const char* key, char* data, int no) 
{
    tList* pp;
    Buffer buf;
    char*  str;
    int    len;
 
    buf = init_Buffer();
    if (list==NULL || key==NULL) return buf;
    if (no<=0) no = 1;
 
    if (data==NULL) {
        buf = buffer_key_tList(list, key, no);
        return buf;
    }
 
    buf = init_Buffer();
    len = (int)strlen(data); 
    
    pp = strncasecmp_tList(list, key, 0, no);
    if (pp!=NULL) {
        str = (char*)pp->ldat.val.buf;
        if (str!=NULL && !strncasecmp(str, data, len)) {
            buf = make_Buffer_bystr(str);
            return buf;
        }
    }
 
    return buf;
}
 
 
/*
int  set_value_tList(tList* list, const char* key, int no, const char* value, int add_mode)
 
リスト(lt)中の no番目の keyノードの値に valueを設定する．
 
no が 0以下の場合は，全ての keyノードの値に対して設定が行われる．@n
keyノードが存在せず，かつ mode==ON の場合は，リストの最後に追加される．
 
@param  list    処理対象のリスト
@param  key     設定を行うノードのキー部．大文字，小文字を区別しない．
@param  value   設定される文字列．
@param  no      keyが一致する何個目のノードに対して設定を行うか．1から数える．0以下の場合はkeyが一致するすべてのノードに対して設定を行う．
@param  add_mod この値がON かつ指定したノードが無い場合，ノードをリストの最後に追加する．
 
@retval 設定されたノードの数 指定されたノードが存在しない場合は（追加された場合も）0
@retval 負数    エラー
*/
int  set_value_tList(tList* list, const char* key, int no, const char* value, int add_mode)
{
    int  cn = 0;
    tList* pm;
 
    if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
 
    if (no>0) {
        pm = strncasecmp_tList(list, key, 0, no);
        if (pm!=NULL) {
            int rep = set_value_tList_node(pm, value);
            if (rep) cn = 1;
        }
    }
    else {        // no<=0
        int nn = 1;
        cn = 0;
        pm = strncasecmp_tList(list, key, 0, nn);
        while (pm!=NULL) {
            int rep = set_value_tList_node(pm, value);
            if (rep) cn++;
            pm = strncasecmp_tList(list, key, 0, ++nn);
        }
    }
 
    // Not Found
    if (add_mode==ON && cn==0) {
        add_tList_node_str(list, key, value);
    }
 
    return cn;
}
 
 
int  set_value_tList_node(tList* lp, const char* value)
{
    if (lp==NULL || value==NULL) return FALSE;
    
    Buffer buf = make_Buffer_bystr(value);
    free_Buffer(&lp->ldat.val);
    lp->ldat.val = buf;
 
    return TRUE;
}
 
 
int  replace_value_tList(tList* list, const char* key, int no, const char* srcval, char* value)
{
    int  cn = 0;
    tList* pm;
 
    if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
    if (srcval==NULL) {
        return set_value_tList(list, key, no, value, OFF);
    }
 
    if (no>0) {
        pm = strncasecmp_tList(list, key, 0, no);
        if (pm!=NULL) {
            int rep = replace_value_tList_node(pm, srcval, value);
            if (rep) cn = 1;
        }
    }
    else {      // no<=0
        int nn = 1;
        cn = 0;
        pm = strncasecmp_tList(list, key, 0, nn);
        while (pm!=NULL) {
            int rep = replace_value_tList_node(pm, srcval, value);
            if (rep) cn++;
            pm = strncasecmp_tList(list, key, 0, ++nn);
        }
    }
    
    return cn;
}
 
 
int  replace_value_tList_node(tList* lp, const char* srcval, const char* value)
{
    if (lp==NULL || value==NULL) return FALSE;
    if (srcval==NULL) {
        return set_value_tList_node(lp, value);
    }
 
    Buffer buf = replace_sBuffer(lp->ldat.val, srcval, value);
    free_Buffer(&lp->ldat.val);
    lp->ldat.val = buf;
    
    return TRUE;
}
    
 
tList*  awk_tList(char* str, char cc)
{
    int  nn = 1;
    char*  item;
    tList* lp = NULL;
 
    if (str==NULL) return NULL;
 
    lp = add_tList_node_bystr(NULL, 1, 0, NULL, NULL, NULL, 0);
 
    // first item
    item = awk(str, cc, nn);
    if (item==NULL) return lp;
    lp->ldat.key = make_Buffer_bystr(item);
 
    //
    item = awk(str, cc, ++nn);
    while (item!=NULL) {
        lp = add_tList_node_bystr(lp, nn, 0, item, NULL, NULL, 0);
        free(item);
        item = awk(str, cc, ++nn);
    }
 
    if (lp!=NULL) lp = find_tList_top(lp);
    return lp;
}
 
 
tList*  cawk_tList(char* str, char cc)
{
    int  nn = 1;
    char*  item;
    tList* lp = NULL;
 
    if (str==NULL) return NULL;
 
    lp = add_tList_node_bystr(NULL, 1, 0, NULL, NULL, NULL, 0);
 
    // first item
    item = cawk(str, cc, nn);
    if (item==NULL) return lp;
    lp->ldat.key = make_Buffer_bystr(item);
 
    //
    item = cawk(str, cc, ++nn);
    while (item!=NULL) {
        lp = add_tList_node_bystr(lp, nn, 0, item, NULL, NULL, 0);
        free(item);
        item = cawk(str, cc, ++nn);
    }
 
    if (lp!=NULL) lp = find_tList_top(lp);
    return lp;
}
 
 
tList*  awk_Buffer_tList(Buffer buf, char cc)
{
    int  nn = 1;
    Buffer item;
    tList* lp = NULL;
 
    if (buf.buf==NULL) return NULL;
 
    item = awk_Buffer(buf, cc, nn);
    while (item.buf!=NULL) {
        lp = add_tList_node_bystr(lp, nn, 0, (char*)item.buf, NULL, NULL, 0);
        free_Buffer(&item);
        item = awk_Buffer(buf, cc, ++nn);
    }
 
    if (lp!=NULL) lp = find_tList_top(lp);
    return lp;
}
 
 
tList*  cawk_Buffer_tList(Buffer buf, char cc)
{
    int  nn = 1;
    Buffer item;
    tList* lp = NULL;
 
    if (buf.buf==NULL) return NULL;
 
    item = cawk_Buffer(buf, cc, nn);
    while (item.buf!=NULL) {
        lp = add_tList_node_bystr(lp, nn, 0, (char*)item.buf, NULL, NULL, 0);
        free_Buffer(&item);
        item = cawk_Buffer(buf, cc, ++nn);
    }
 
    if (lp!=NULL) lp = find_tList_top(lp);
    return lp;
 
}
 
 
char*  get_str_join_tList(tList* lp, const char* deli)
{
    Buffer buf = get_Buffer_join_tList(lp, deli);
    return (char*)buf.buf;
}
 
 
Buffer  get_Buffer_join_tList(tList* lp, const char* deli)
{
    Buffer buf;
    
    buf = init_Buffer();
    if (lp==NULL) return buf;
 
    buf = make_Buffer(LBUF);
 
    if (lp!=NULL && lp->ldat.key.buf!=NULL) {
        cat_s2Buffer((char*)lp->ldat.key.buf, &buf);
        lp = lp->next;
 
        while (lp!=NULL && lp->ldat.key.buf!=NULL) {
            if (deli!=NULL) cat_s2Buffer(deli, &buf);
            cat_s2Buffer((char*)lp->ldat.key.buf, &buf);
            lp = lp->next;
        }
    }
 
    return buf;
}
 
 
 
// for Configuration File
//
 
char*  get_str_param_tList(tList* lt, const char* key, const char* dflt)
{
    Buffer buf;
 
    buf = buffer_key_tList(lt, key, 1);
    if (buf.buf==NULL) buf = make_Buffer_bystr(dflt);
        
    return (char*)buf.buf;
}
 
 
int  get_int_param_tList(tList* lt, const char* key, int dflt)
{
    Buffer buf;
 
    buf = buffer_key_tList(lt, key, 1);
    if (buf.buf!=NULL) {
        int ret = atoi((char*)buf.buf);
        free_Buffer(&buf);
        return ret;
    }
    return dflt;
}
 
 
double  get_double_param_tList(tList* lt, const char* key, double dflt)
{
    Buffer buf;
 
    buf = buffer_key_tList(lt, key, 1);
    if (buf.buf!=NULL) {
        double ret = atof((char*)buf.buf);
        free_Buffer(&buf);
        return ret;
    }
    return dflt;
}
 
 
float  get_float_param_tList(tList* lt, const char* key, float dflt)
{
    Buffer buf;
 
    buf = buffer_key_tList(lt, key, 1);
    if (buf.buf!=NULL) {
        float ret = (float)atof((char*)buf.buf);
        free_Buffer(&buf);
        return ret;
    }
    return dflt;
}
 
 
int  get_bool_param_tList(tList* lt, const char* key, int dflt)
{
    int  ret = dflt;
    char* val = NULL;
 
    if (dflt) val = get_str_param_tList(lt, key, "true");
    else      val = get_str_param_tList(lt, key, "false");
 
    if (val!=NULL) {
        if (!strcasecmp("true", val)) ret = 1;       // TRUE
        else ret = 0;                                // FALSE
        free(val);
    }
 
    return ret;
}
 
 
 
// Tiny List File I/O
//
 
tList*  read_tList_file(const char* fname, int mode) 
{
    tList* lp = NULL;
    FILE* fp;
 
    fp = fopen(fname, "rb");
    if (fp!=NULL) {
        lp = read_tList_fp(fp, mode);
        fclose(fp);
    }
 
    return lp;
}
 
 
tList*  read_tList_fp(FILE* fp, int mode) 
{
    char    val[LBUF+1];
    char*   str;
    tList*  lp = NULL;
    tList*  lt = NULL;
 
    if (fp==NULL) return NULL;
 
    str = fgets(val, LBUF, fp);     // str is unused
    while (!feof(fp)) {
        if (mode>0) {
            if (mode>1) {
                int i;
                for (i=0; i<(int)strlen(val); i++) {
                    if (val[i]=='#') {
                        val[i] = '\0';
                        break;
                    }
                    if (i>=LBUF) break;
                }
            }
            str = pack_char(val, ' ');
        }
        else {
            str = (char*)malloc(LBUF+1);
            if (str!=NULL) {
                memset(str, 0, LBUF+1);
                strncpy(val, str, LBUF);
            }
        }
 
        if (str!=NULL) {
            if (strlen(str)>0) {    // 空行のチェック
                if (mode==0 || str[0]!='#') {
                    lt = add_tList_node_str(lt, str, NULL);
                    if (lp==NULL) lp = lt;
                }
            }
            free(str);
        }
        str = fgets(val, LBUF, fp);     // str is unused
    }
    
    return lp;
}
 
 
tList*  read_index_tList_file(const char* fname, char deli) 
{
    tList* lp = NULL;
    FILE* fp;
 
    fp = fopen(fname, "rb");
    if (fp!=NULL) {
        lp = read_index_tList_fp(fp, deli);
        fclose(fp);
    }
    return lp;
}
 
 
tList*  read_index_tList_fp(FILE* fp, char deli)
{
    Buffer key, val;
    Buffer fst, snd;
    tList* pl;
    tList* pp;
    tList* lt = NULL;
 
    pp = pl = read_tList_fp(fp, 1);
    while (pp!=NULL) {
        fst = awk_Buffer(pp->ldat.key, deli, 1);
        //snd = awk_Buffer(pp->ldat.key, deli, 2);
        //snd = make_Buffer_bystr((char*)&(pp->ldat.key.buf[fst.vldsz]));
        snd = make_Buffer_bystr((char*)&(pp->ldat.key.buf[fst.vldsz]) + 1);
        key = pack_Buffer(fst, ' ');
        val = pack_Buffer(snd, ' ');
        if (lt==NULL) lt = add_tList_node_byBuffer(NULL, 0, 0, key, val, NULL, 0);
        else               add_tList_node_byBuffer(lt,   0, 0, key, val, NULL, 0);
    
        free_Buffer(&key);
        free_Buffer(&val);
        free_Buffer(&fst);
        free_Buffer(&snd);
        
        pp = pp->next;
    }
    del_all_tList(&pl);
 
    return lt;
}
 
 
tList*  read_Buffer_tList_file(const char* fname) 
{
    tList* lp = NULL;
    FILE* fp;
 
    fp = fopen(fname, "rb");
    if (fp!=NULL) {
        lp = read_Buffer_tList_fp(fp);
        fclose(fp);
    }
    return lp;
}
 
 
tList*  read_Buffer_tList_fp(FILE* fp) 
{
    int  cc;
    tList*  lp = NULL;
    tList*  lt = NULL;
    Buffer key, val;
 
    if (fp==NULL) return NULL;
 
    cc = read_Buffer2_format_fp(&key, &val, fp);
    while (!feof(fp) && cc) {
        lt = add_tList_node_Buffer(lt, key, val);
        if (lp==NULL) lp = lt;
        free_Buffer(&key);    
        free_Buffer(&val);    
        cc = read_Buffer2_format_fp(&key, &val, fp);
    }
    
    free_Buffer(&key);    
    free_Buffer(&val);    
    return lp;
}
 
 
int  save_Buffer_tList_file(const char* fname, tList* lp) 
{
    int  ret=FALSE;
    FILE* fp;
 
    fp = fopen(fname, "ab");
    if (fp!=NULL) {
        ret = save_Buffer_tList_fp(fp, lp);
        fclose(fp);
    }
    return ret;
}
 
 
int  save_Buffer_tList_fp(FILE* fp, tList* lp) 
{
    int cc=TRUE;
 
    if (fp==NULL) return FALSE;
 
    while (lp!=NULL && cc) {
        cc = save_Buffer2_format_fp(lp->ldat.key, lp->ldat.val, fp);    
        lp = lp->next;
    }
 
    if (!cc) return FALSE;
    return TRUE;
}