hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

oh my lda!

Browse Source
This commit is contained in:
hyung-hwan 2008-10-10 05:45:49 +00:00
parent dd2d9190c0
commit b2d1b51302
3 changed files with 213 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
ase/include/ase/cmn/lda.h
View File

@ -10,11 +10,6 @@
#include <ase/types.h> #include <ase/types.h>
#include <ase/macros.h> #include <ase/macros.h>
enum ase_lda_opt_t
{
ASE_LDA_NODLEN = (((ase_uint4_t)1) << 16)
};
/****o* ase.cmn.lda/linear dynamic array /****o* ase.cmn.lda/linear dynamic array
* DESCRIPTION * DESCRIPTION
* <ase/cmn/lda.h> provides a linear dynamic array. It grows as more items * <ase/cmn/lda.h> provides a linear dynamic array. It grows as more items
@ -25,7 +20,7 @@ enum ase_lda_opt_t
*/ */
typedef struct ase_lda_t ase_lda_t; typedef struct ase_lda_t ase_lda_t;
typedef struct ase_lda_cell_t ase_lda_cell_t; typedef struct ase_lda_node_t ase_lda_node_t;
#define ASE_LDA_COPIER_SIMPLE ase_lda_copysimple #define ASE_LDA_COPIER_SIMPLE ase_lda_copysimple
#define ASE_LDA_COPIER_INLINE ase_lda_copyinline #define ASE_LDA_COPIER_INLINE ase_lda_copyinline
@ -34,15 +29,16 @@ typedef struct ase_lda_cell_t ase_lda_cell_t;
#define ASE_LDA_SIZE(lda) ((lda)->size) #define ASE_LDA_SIZE(lda) ((lda)->size)
#define ASE_LDA_CAPA(lda) ((lda)->capa) #define ASE_LDA_CAPA(lda) ((lda)->capa)
#define ASE_LDA_CELL(lda,index) ((lda)->cell[index])
#define ASE_LDA_DPTR(cell) ((cell)->dptr) #define ASE_LDA_NODE(lda,index) ((lda)->node[index])
#define ASE_LDA_DLEN(cell) ((cell)->dlen) #define ASE_LDA_DPTR(lda,index) ((lda)->node[index]->dptr)
#define ASE_LDA_DLEN(lda,index) ((lda)->node[index]->dlen)
#define ASE_LDA_MMGR(lda) ((lda)->mmgr) #define ASE_LDA_MMGR(lda) ((lda)->mmgr)
#define ASE_LDA_COPIER(lda) ((lda)->copier) #define ASE_LDA_COPIER(lda) ((lda)->copier)
#define ASE_LDA_FREEER(lda) ((lda)->freeer) #define ASE_LDA_FREEER(lda) ((lda)->freeer)
#define ASE_LDA_COMPER(lda) ((lda)->comper) #define ASE_LDA_COMPER(lda) ((lda)->comper)
#define ASE_LDA_KEEPER(lda) ((lda)->keeper)
#define ASE_LDA_SIZER(lda) ((lda)->sizer) #define ASE_LDA_SIZER(lda) ((lda)->sizer)
@ -110,6 +106,25 @@ typedef int (*ase_lda_comper_t) (
); );
/******/ /******/
/****t* ase.cmn.lda/ase_lda_keeper_t
* NAME
* ase_lda_keeper_t - define a value keeper
*
* DESCRIPTION
* The ase_lda_keeper_t type defines a value keeper that is called when
* a value is retained in the context that it should be destroyed because
* it is identical to a new value. Two values are identical if their beginning
* pointers and their lengths are equal.
*
* SYNOPSIS
*/
typedef void (*ase_lda_keeper_t) (
ase_lda_t* lda /* a lda */,
void* vptr /* the pointer to a value */,
ase_size_t vlen /* the length of a value */
);
/******/
/****t* ase.cmn.lda/ase_lda_sizer_t /****t* ase.cmn.lda/ase_lda_sizer_t
* NAME * NAME
* ase_lda_sizer_t - define an array size calculator * ase_lda_sizer_t - define an array size calculator
@ -140,26 +155,22 @@ struct ase_lda_t
ase_lda_copier_t copier; /* data copier */ ase_lda_copier_t copier; /* data copier */
ase_lda_freeer_t freeer; /* data freeer */ ase_lda_freeer_t freeer; /* data freeer */
ase_lda_comper_t comper; /* data comparator */ ase_lda_comper_t comper; /* data comparator */
ase_lda_keeper_t keeper; /* data keeper */
ase_lda_sizer_t sizer; /* size calculator */ ase_lda_sizer_t sizer; /* size calculator */
ase_byte_t scale; /* scale factor */ ase_byte_t scale; /* scale factor */
ase_uint16_t opt;
ase_size_t size; /* the number of items */ ase_size_t size; /* the number of items */
ase_size_t capa; /* capacity */ ase_size_t capa; /* capacity */
ase_lda_node_t** node;
/*ase_lda_cell_t** cell;*/
void* cell;
}; };
/******/ /******/
/****s* /****s*
* NAME * NAME
* ase_lda_cell_t - define a linear dynamic array cell * ase_lda_node_t - define a linear dynamic array node
* *
* SYNOPSIS * SYNOPSIS
*/ */
struct ase_lda_cell_t struct ase_lda_node_t
{ {
void* dptr; void* dptr;
ase_size_t dlen; ase_size_t dlen;
@ -179,8 +190,7 @@ extern "C" {
ase_lda_t* ase_lda_open ( ase_lda_t* ase_lda_open (
ase_mmgr_t* lda, ase_mmgr_t* lda,
ase_size_t ext, ase_size_t ext,
ase_size_t capa, ase_size_t capa
ase_uint4_t opt
); );
/******/ /******/
@ -360,6 +370,20 @@ ase_size_t ase_lda_rsearch (
ase_size_t dlen ase_size_t dlen
); );
ase_size_t ase_lda_rrsearch (
ase_lda_t* lda,
ase_size_t pos,
const void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_upsert (
ase_lda_t* lda,
ase_size_t index,
void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_insert ( ase_size_t ase_lda_insert (
ase_lda_t* lda, ase_lda_t* lda,
ase_size_t index, ase_size_t index,
@ -367,6 +391,13 @@ ase_size_t ase_lda_insert (
ase_size_t dlen ase_size_t dlen
); );
ase_size_t ase_lda_update (
ase_lda_t* lda,
ase_size_t pos,
void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_delete ( ase_size_t ase_lda_delete (
ase_lda_t* lda, ase_lda_t* lda,
ase_size_t index, ase_size_t index,

8
ase/include/ase/cmn/map.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: map.h 409 2008-10-08 11:43:56Z baconevi $ * $Id: map.h 413 2008-10-09 11:45:49Z baconevi $
* *
* {License} * {License}
*/ */
@ -164,10 +164,8 @@ struct ase_map_pair_t
{ {
void* kptr; /* the pointer to a key */ void* kptr; /* the pointer to a key */
ase_size_t klen; /* the length of a key */ ase_size_t klen; /* the length of a key */
void* vptr; /* the pointer to a value */ void* vptr; /* the pointer to a value */
ase_size_t vlen; /* the length of a value */ ase_size_t vlen; /* the length of a value */
ase_map_pair_t* next; /* the next pair under the same slot */ ase_map_pair_t* next; /* the next pair under the same slot */
}; };
/*****/ /*****/
@ -181,22 +179,18 @@ struct ase_map_pair_t
struct ase_map_t struct ase_map_t
{ {
ase_mmgr_t* mmgr; ase_mmgr_t* mmgr;
ase_map_copier_t copier[2]; ase_map_copier_t copier[2];
ase_map_freeer_t freeer[2]; ase_map_freeer_t freeer[2];
ase_map_hasher_t hasher; /* key hasher */ ase_map_hasher_t hasher; /* key hasher */
ase_map_comper_t comper; /* key comparator */ ase_map_comper_t comper; /* key comparator */
ase_map_keeper_t keeper; /* value keeper */ ase_map_keeper_t keeper; /* value keeper */
ase_map_sizer_t sizer; /* bucket capacity recalculator */ ase_map_sizer_t sizer; /* bucket capacity recalculator */
ase_byte_t scale[2]; /* length scale */ ase_byte_t scale[2]; /* length scale */
ase_byte_t factor; /* load factor */ ase_byte_t factor; /* load factor */
ase_byte_t filler0; ase_byte_t filler0;
ase_size_t size; ase_size_t size;
ase_size_t capa; ase_size_t capa;
ase_size_t threshold; ase_size_t threshold;
ase_map_pair_t** bucket; ase_map_pair_t** bucket;
}; };
/******/ /******/

198
ase/lib/cmn/lda.c
View File

@ -8,7 +8,7 @@
#include "mem.h" #include "mem.h"
#define lda_t ase_lda_t #define lda_t ase_lda_t
#define cell_t ase_lda_cell_t #define node_t ase_lda_node_t
#define copier_t ase_lda_copier_t #define copier_t ase_lda_copier_t
#define freeer_t ase_lda_freeer_t #define freeer_t ase_lda_freeer_t
#define comper_t ase_lda_comper_t #define comper_t ase_lda_comper_t
@ -17,18 +17,12 @@
#define mmgr_t ase_mmgr_t #define mmgr_t ase_mmgr_t
#define size_t ase_size_t #define size_t ase_size_t
#define uint4_t ase_uint4_t
#define TOB(lda,len) ((len)*(lda)->scale) #define TOB(lda,len) ((len)*(lda)->scale)
#define DPTR(cell) ASE_LDA_DPTR(cell) #define DPTR(node) ((node)->dptr)
#define DLEN(cell) ASE_LDA_DLEN(cell) #define DLEN(node) ((node)->dlen)
#define INVALID ASE_LDA_INVALID #define INVALID ASE_LDA_INVALID
/* get cell size */
#define CS(lda) ((lda)->opt & 0xFFFF)
/* check if the option is set */
#define OPT(lda,o) ((lda)->opt & (o))
static int comp_data (lda_t* lda, static int comp_data (lda_t* lda,
const void* dptr1, size_t dlen1, const void* dptr1, size_t dlen1,
const void* dptr2, size_t dlen2) const void* dptr2, size_t dlen2)
@ -48,20 +42,20 @@ static int comp_data (lda_t* lda,
return n; return n;
} }
static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen) static node_t* alloc_node (lda_t* lda, void* dptr, size_t dlen)
{ {
cell_t* n; node_t* n;
if (lda->copier == ASE_LDA_COPIER_SIMPLE) if (lda->copier == ASE_LDA_COPIER_SIMPLE)
{ {
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(cell_t)); n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(node_t));
if (n == ASE_NULL) return ASE_NULL; if (n == ASE_NULL) return ASE_NULL;
DPTR(n) = dptr; DPTR(n) = dptr;
} }
else if (lda->copier == ASE_LDA_COPIER_INLINE) else if (lda->copier == ASE_LDA_COPIER_INLINE)
{ {
n = ASE_MMGR_ALLOC (lda->mmgr, n = ASE_MMGR_ALLOC (lda->mmgr,
ASE_SIZEOF(cell_t) + TOB(lda,dlen)); ASE_SIZEOF(node_t) + TOB(lda,dlen));
if (n == ASE_NULL) return ASE_NULL; if (n == ASE_NULL) return ASE_NULL;
ASE_MEMCPY (n + 1, dptr, TOB(lda,dlen)); ASE_MEMCPY (n + 1, dptr, TOB(lda,dlen));
@ -69,7 +63,7 @@ static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen)
} }
else else
{ {
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(cell_t)); n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(node_t));
if (n == ASE_NULL) return ASE_NULL; if (n == ASE_NULL) return ASE_NULL;
DPTR(n) = lda->copier (lda, dptr, dlen); DPTR(n) = lda->copier (lda, dptr, dlen);
if (DPTR(n) == ASE_NULL) if (DPTR(n) == ASE_NULL)
@ -84,7 +78,7 @@ static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen)
return n; return n;
} }
lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa, uint4_t opt) lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa)
{ {
lda_t* lda; lda_t* lda;
@ -101,7 +95,7 @@ lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa, uint4_t opt)
lda = ASE_MMGR_ALLOC (mmgr, ASE_SIZEOF(lda_t) + ext); lda = ASE_MMGR_ALLOC (mmgr, ASE_SIZEOF(lda_t) + ext);
if (lda == ASE_NULL) return ASE_NULL; if (lda == ASE_NULL) return ASE_NULL;
return ase_lda_init (lda, mmgr, capa, opt); return ase_lda_init (lda, mmgr, capa);
} }
void ase_lda_close (lda_t* lda) void ase_lda_close (lda_t* lda)
@ -110,15 +104,14 @@ void ase_lda_close (lda_t* lda)
ASE_MMGR_FREE (lda->mmgr, lda); ASE_MMGR_FREE (lda->mmgr, lda);
} }
lda_t* ase_lda_init (lda_t* lda, mmgr_t* mmgr, size_t capa, uint4_t opt) lda_t* ase_lda_init (lda_t* lda, mmgr_t* mmgr, size_t capa)
{ {
ASE_MEMSET (lda, 0, ASE_SIZEOF(*lda)); ASE_MEMSET (lda, 0, ASE_SIZEOF(*lda));
lda->mmgr = mmgr; lda->mmgr = mmgr;
lda->size = 0; lda->size = 0;
lda->capa = 0; lda->capa = 0;
lda->opt = opt; lda->node = ASE_NULL;
lda->cell = ASE_NULL;
lda->copier = ASE_LDA_COPIER_SIMPLE; lda->copier = ASE_LDA_COPIER_SIMPLE;
lda->comper = comp_data; lda->comper = comp_data;
@ -131,10 +124,10 @@ void ase_lda_fini (lda_t* lda)
{ {
ase_lda_clear (lda); ase_lda_clear (lda);
if (lda->cell != ASE_NULL) if (lda->node != ASE_NULL)
{ {
ASE_MMGR_FREE (lda->mmgr, lda->cell); ASE_MMGR_FREE (lda->mmgr, lda->node);
lda->cell = ASE_NULL; lda->node = ASE_NULL;
lda->capa = 0; lda->capa = 0;
} }
} }
@ -234,42 +227,42 @@ lda_t* ase_lda_setcapa (lda_t* lda, size_t capa)
if (capa > 0) if (capa > 0)
{ {
if (lda->mmgr->realloc != ASE_NULL) if (lda->mmgr->realloc != ASE_NULL && lda->node != ASE_NULL)
{ {
/*tmp = ASE_MMGR_REALLOC (lda->mmgr, wprintf (L"XXXXXXXXXXXXXXXXXX %d, %d\n", (int)capa, (int)ASE_SIZEOF(*lda->node)*capa);
lda->cell, ASE_SIZEOF(*lda->cell) * capa);*/ tmp = (ase_lda_node_t**)ASE_MMGR_REALLOC (
tmp = ASE_MMGR_REALLOC (lda->mmgr, CS(lda)*capa); lda->mmgr, lda->node, ASE_SIZEOF(*lda->node)*capa);
if (tmp == ASE_NULL) return ASE_NULL; if (tmp == ASE_NULL) return ASE_NULL;
} }
else else
{ {
/*tmp = ASE_MMGR_ALLOC ( wprintf (L"XXXXXXXXXXXXXXXXXX %d, %d\n", (int)capa, (int)ASE_SIZEOF(*lda->node)*capa);
lda->mmgr, ASE_SIZEOF(*lda->cell) * capa);*/ tmp = (ase_lda_node_t**) ASE_MMGR_ALLOC (
tmp = ASE_MMGR_ALLOC (lda->mmgr, CS(lda)*capa); lda->mmgr, ASE_SIZEOF(*lda->node)*capa);
if (tmp == ASE_NULL) return ASE_NULL; if (tmp == ASE_NULL) return ASE_NULL;
if (lda->cell != ASE_NULL)
if (lda->node != ASE_NULL)
{ {
size_t x; size_t x;
x = (capa > lda->capa)? lda->capa: capa; x = (capa > lda->capa)? lda->capa: capa;
/*ASE_MEMCPY (tmp, lda->cell, ASE_MEMCPY (tmp, lda->node,
ASE_SIZEOF(*lda->cell) * x);*/ ASE_SIZEOF(*lda->node) * x);
ASE_MEMCPY (tmp, lda->cell, CS(lda)*x); ASE_MMGR_FREE (lda->mmgr, lda->node);
ASE_MMGR_FREE (lda->mmgr, lda->cell);
} }
} }
} }
else else
{ {
if (lda->cell != ASE_NULL) if (lda->node != ASE_NULL)
{ {
ase_lda_clear (lda); ase_lda_clear (lda);
ASE_MMGR_FREE (lda->mmgr, lda->cell); ASE_MMGR_FREE (lda->mmgr, lda->node);
} }
tmp = ASE_NULL; tmp = ASE_NULL;
} }
lda->cell = tmp; lda->node = tmp;
lda->capa = capa; lda->capa = capa;
return lda; return lda;
@ -282,7 +275,7 @@ size_t ase_lda_search (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = pos; i < lda->size; i++) for (i = pos; i < lda->size; i++)
{ {
if (lda->comper (lda, if (lda->comper (lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]), DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i; dptr, dlen) == 0) return i;
} }
@ -298,7 +291,7 @@ size_t ase_lda_rsearch (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = pos + 1; i-- > 0; ) for (i = pos + 1; i-- > 0; )
{ {
if (lda->comper (lda, if (lda->comper (lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]), DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i; dptr, dlen) == 0) return i;
} }
@ -314,42 +307,78 @@ size_t ase_lda_rrsearch (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = lda->size - pos; i-- > 0; ) for (i = lda->size - pos; i-- > 0; )
{ {
if (lda->comper (lda, if (lda->comper (lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]), DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i; dptr, dlen) == 0) return i;
} }
return INVALID; return INVALID;
} }
size_t ase_lda_upsert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{
if (pos < lda->size) return ase_lda_update (lda, pos, dptr, dlen);
return ase_lda_insert (lda, pos, dptr, dlen);
}
size_t ase_lda_insert (lda_t* lda, size_t pos, void* dptr, size_t dlen) size_t ase_lda_insert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{ {
size_t i; size_t i;
cell_t* cell; node_t* node;
cell = alloc_cell (lda, dptr, dlen); /* allocate the node first */
if (cell == ASE_NULL) return INVALID; node = alloc_node (lda, dptr, dlen);
if (node == ASE_NULL) return INVALID;
if (pos >= lda->capa) /* do resizeing if necessary.
* resizing is performed after node allocation because that way, it
* doesn't modify lda on any errors */
if (pos >= lda->capa || lda->size >= lda->capa)
{ {
size_t capa; size_t capa;
if (lda->capa <= 0) capa = (pos + 1); if (lda->sizer)
{
capa = (pos >= lda->size)? (pos + 1): (lda->size + 1);
capa = lda->sizer (lda, capa);
}
else else
{ {
do { capa = lda->capa * 2; } while (pos >= capa); if (lda->capa <= 0)
{
ASE_ASSERT (lda->size <= 0);
capa = (pos < 16)? 16: (pos + 1);
}
else
{
size_t bound = (pos >= lda->size)? pos: lda->size;
do { capa = lda->capa * 2; } while (capa <= bound);
}
} }
if (ase_lda_setcapa(lda,capa) == ASE_NULL) if (ase_lda_setcapa(lda,capa) == ASE_NULL)
{ {
if (lda->freeer) if (lda->freeer)
lda->freeer (lda, DPTR(cell), DLEN(cell)); lda->freeer (lda, DPTR(node), DLEN(node));
return INVALID; return INVALID;
} }
} }
for (i = lda->size; i > pos; i--) if (pos >= lda->capa)
lda->cell[i] = lda->cell[i-1]; {
lda->cell[pos] = cell; /* the buffer is not still enough after resizing */
if (lda->freeer)
lda->freeer (lda, DPTR(node), DLEN(node));
return INVALID;
}
/* fill in the gap with ASE_NULL */
for (i = lda->size; i < pos; i++) lda->node[i] = ASE_NULL;
/* shift values to the next cell */
for (i = lda->size; i > pos; i--) lda->node[i] = lda->node[i-1];
/* set the value */
lda->node[pos] = node;
if (pos > lda->size) lda->size = pos + 1; if (pos > lda->size) lda->size = pos + 1;
else lda->size++; else lda->size++;
@ -357,6 +386,43 @@ size_t ase_lda_insert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
return pos; return pos;
} }
size_t ase_lda_update (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{
node_t* c;
if (pos >= lda->size) return INVALID;
c = lda->node[pos];
if (c == ASE_NULL)
{
/* no previous data */
lda->node[pos] = alloc_node (lda, dptr, dlen);
if (lda->node[pos] == ASE_NULL) return INVALID;
}
else
{
if (dptr == DPTR(c) && dlen == DLEN(c))
{
/* updated to the same data */
lda->keeper (lda, dptr, dlen);
}
else
{
/* updated to different data */
node_t* node = alloc_node (lda, dptr, dlen);
if (node == ASE_NULL) return INVALID;
if (lda->freeer != ASE_NULL)
lda->freeer (lda, DPTR(c), DLEN(c));
ASE_MMGR_FREE (lda->mmgr, c);
lda->node[pos] = node;
}
}
return pos;
}
size_t ase_lda_delete (lda_t* lda, size_t index, size_t count) size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
{ {
size_t i, j, k; size_t i, j, k;
@ -370,7 +436,7 @@ size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
while (i < k) while (i < k)
{ {
cell_t* c = lda->cell[i]; node_t* c = lda->node[i];
if (lda->freeer != ASE_NULL) if (lda->freeer != ASE_NULL)
lda->freeer (lda, DPTR(c), DLEN(c)); lda->freeer (lda, DPTR(c), DLEN(c));
@ -378,12 +444,12 @@ size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
if (j >= lda->size) if (j >= lda->size)
{ {
lda->cell[i] = ASE_NULL; lda->node[i] = ASE_NULL;
i++; i++;
} }
else else
{ {
lda->cell[i] = lda->cell[j]; lda->node[i] = lda->node[j];
i++; j++; i++; j++;
} }
} }
@ -398,11 +464,11 @@ void ase_lda_clear (lda_t* lda)
for (i = 0; i < lda->size; i++) for (i = 0; i < lda->size; i++)
{ {
cell_t* c = lda->cell[i]; node_t* c = lda->node[i];
if (lda->freeer) if (c && lda->freeer)
lda->freeer (lda, DPTR(c), DLEN(c)); lda->freeer (lda, DPTR(c), DLEN(c));
ASE_MMGR_FREE (lda->mmgr, c); ASE_MMGR_FREE (lda->mmgr, c);
lda->cell[i] = ASE_NULL; lda->node[i] = ASE_NULL;
} }
lda->size = 0; lda->size = 0;
@ -433,7 +499,7 @@ size_t ase_lda_find (lda_t* lda, size_t index, const ase_char_t* str, size_t len
for (i = index; i < lda->size; i++) for (i = index; i < lda->size; i++)
{ {
if (ase_strxncmp ( if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len, lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i; str, len) == 0) return i;
} }
@ -449,7 +515,7 @@ size_t ase_lda_rfind (lda_t* lda, size_t index, const ase_char_t* str, size_t le
for (i = index + 1; i-- > 0; ) for (i = index + 1; i-- > 0; )
{ {
if (ase_strxncmp ( if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len, lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i; str, len) == 0) return i;
} }
@ -465,7 +531,7 @@ size_t ase_lda_rrfind (lda_t* lda, size_t index, const ase_char_t* str, size_t l
for (i = lda->size - index; i-- > 0; ) for (i = lda->size - index; i-- > 0; )
{ {
if (ase_strxncmp ( if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len, lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i; str, len) == 0) return i;
} }
@ -483,8 +549,8 @@ size_t ase_lda_findx (
{ {
ase_cstr_t x; ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr; x.ptr = lda->node[i].name.ptr;
x.len = lda->cell[i].name.len; x.len = lda->node[i].name.len;
transform (i, &x, arg); transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i; if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;
@ -506,8 +572,8 @@ size_t ase_lda_rfindx (
{ {
ase_cstr_t x; ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr; x.ptr = lda->node[i].name.ptr;
x.len = lda->cell[i].name.len; x.len = lda->node[i].name.len;
transform (i, &x, arg); transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i; if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;
@ -529,8 +595,8 @@ size_t ase_lda_rrfindx (
{ {
ase_cstr_t x; ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr; x.ptr = lda->node[i].name.ptr;
x.len = lda->cell[i].name.len; x.len = lda->node[i].name.len;
transform (i, &x, arg); transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i; if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;