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

renamed hcl to hak

Browse Source
This commit is contained in:
hyung-hwan
2025-09-02 23:58:15 +09:00
parent be77ac8ad2
commit 20d2db0e27
129 changed files with 43690 additions and 43689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
lib/utl.c
View File

@ -22,9 +22,9 @@
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <hcl-utl.h>
#include <hcl-str.h>
#include <hcl.h>
#include <hak-utl.h>
#include <hak-str.h>
#include <hak.h>
/* some naming conventions
* bchars, uchars -> pointer and length
@ -35,73 +35,73 @@
* utobcstr -> ucstr to bcstr
*/
hcl_oow_t hcl_hash_bytes_ (const hcl_oob_t* ptr, hcl_oow_t len)
hak_oow_t hak_hash_bytes_ (const hak_oob_t* ptr, hak_oow_t len)
{
hcl_oow_t hv;
HCL_HASH_BYTES (hv, ptr, len);
hak_oow_t hv;
HAK_HASH_BYTES (hv, ptr, len);
/* constrain the hash value to be representable in a small integer
* for convenience sake */
return hv % ((hcl_oow_t)HCL_SMOOI_MAX + 1);
return hv % ((hak_oow_t)HAK_SMOOI_MAX + 1);
}
/* ----------------------------------------------------------------------- */
int hcl_convbtouchars (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen)
int hak_convbtouchars (hak_t* hak, const hak_bch_t* bcs, hak_oow_t* bcslen, hak_uch_t* ucs, hak_oow_t* ucslen)
{
/* length bound */
int n;
n = hcl_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, HCL_CMGR(hcl), 0);
n = hak_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, HAK_CMGR(hak), 0);
if (n <= -1)
{
/* -1: illegal character, -2: buffer too small, -3: incomplete sequence */
hcl_seterrnum (hcl, (n == -2)? HCL_EBUFFULL: HCL_EECERR);
hak_seterrnum (hak, (n == -2)? HAK_EBUFFULL: HAK_EECERR);
}
return n;
}
int hcl_convutobchars (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen)
int hak_convutobchars (hak_t* hak, const hak_uch_t* ucs, hak_oow_t* ucslen, hak_bch_t* bcs, hak_oow_t* bcslen)
{
/* length bound */
int n;
n = hcl_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, HCL_CMGR(hcl));
n = hak_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, HAK_CMGR(hak));
if (n <= -1)
{
hcl_seterrnum (hcl, (n == -2)? HCL_EBUFFULL: HCL_EECERR);
hak_seterrnum (hak, (n == -2)? HAK_EBUFFULL: HAK_EECERR);
}
return n;
}
int hcl_convbtoucstr (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen)
int hak_convbtoucstr (hak_t* hak, const hak_bch_t* bcs, hak_oow_t* bcslen, hak_uch_t* ucs, hak_oow_t* ucslen)
{
/* null-terminated. */
int n;
n = hcl_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, HCL_CMGR(hcl), 0);
n = hak_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, HAK_CMGR(hak), 0);
if (n <= -1)
{
hcl_seterrnum (hcl, (n == -2)? HCL_EBUFFULL: HCL_EECERR);
hak_seterrnum (hak, (n == -2)? HAK_EBUFFULL: HAK_EECERR);
}
return n;
}
int hcl_convutobcstr (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen)
int hak_convutobcstr (hak_t* hak, const hak_uch_t* ucs, hak_oow_t* ucslen, hak_bch_t* bcs, hak_oow_t* bcslen)
{
/* null-terminated */
int n;
n = hcl_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, HCL_CMGR(hcl));
n = hak_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, HAK_CMGR(hak));
if (n <= -1)
{
hcl_seterrnum (hcl, (n == -2)? HCL_EBUFFULL: HCL_EECERR);
hak_seterrnum (hak, (n == -2)? HAK_EBUFFULL: HAK_EECERR);
}
return n;
@ -109,169 +109,169 @@ int hcl_convutobcstr (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_b
/* ----------------------------------------------------------------------- */
hcl_uch_t* hcl_dupbtoucharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t bcslen, hcl_oow_t* ucslen)
hak_uch_t* hak_dupbtoucharswithheadroom (hak_t* hak, hak_oow_t headroom_bytes, const hak_bch_t* bcs, hak_oow_t bcslen, hak_oow_t* ucslen)
{
hcl_oow_t inlen, outlen;
hcl_uch_t* ptr;
hak_oow_t inlen, outlen;
hak_uch_t* ptr;
inlen = bcslen;
if (hcl_convbtouchars (hcl, bcs, &inlen, HCL_NULL, &outlen) <= -1)
if (hak_convbtouchars (hak, bcs, &inlen, HAK_NULL, &outlen) <= -1)
{
/* note it's also an error if no full conversion is made in this function */
return HCL_NULL;
return HAK_NULL;
}
ptr = (hcl_uch_t*)hcl_allocmem(hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_uch_t)));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_uch_t*)hak_allocmem(hak, headroom_bytes + ((outlen + 1) * HAK_SIZEOF(hak_uch_t)));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
inlen = bcslen;
ptr = (hcl_uch_t*)((hcl_oob_t*)ptr + headroom_bytes);
hcl_convbtouchars (hcl, bcs, &inlen, ptr, &outlen);
ptr = (hak_uch_t*)((hak_oob_t*)ptr + headroom_bytes);
hak_convbtouchars (hak, bcs, &inlen, ptr, &outlen);
/* hcl_convbtouchars() doesn't null-terminate the target.
* but in hcl_dupbtouchars(), i allocate space. so i don't mind
/* hak_convbtouchars() doesn't null-terminate the target.
* but in hak_dupbtouchars(), i allocate space. so i don't mind
* null-terminating it with 1 extra character overhead */
ptr[outlen] = '\0';
if (ucslen) *ucslen = outlen;
return ptr;
}
hcl_uch_t* hcl_dupbtouchars (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t bcslen, hcl_oow_t* ucslen)
hak_uch_t* hak_dupbtouchars (hak_t* hak, const hak_bch_t* bcs, hak_oow_t bcslen, hak_oow_t* ucslen)
{
return hcl_dupbtoucharswithheadroom (hcl, 0, bcs, bcslen, ucslen);
return hak_dupbtoucharswithheadroom (hak, 0, bcs, bcslen, ucslen);
}
hcl_bch_t* hcl_duputobcharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t ucslen, hcl_oow_t* bcslen)
hak_bch_t* hak_duputobcharswithheadroom (hak_t* hak, hak_oow_t headroom_bytes, const hak_uch_t* ucs, hak_oow_t ucslen, hak_oow_t* bcslen)
{
hcl_oow_t inlen, outlen;
hcl_bch_t* ptr;
hak_oow_t inlen, outlen;
hak_bch_t* ptr;
inlen = ucslen;
if (hcl_convutobchars(hcl, ucs, &inlen, HCL_NULL, &outlen) <= -1)
if (hak_convutobchars(hak, ucs, &inlen, HAK_NULL, &outlen) <= -1)
{
/* note it's also an error if no full conversion is made in this function */
return HCL_NULL;
return HAK_NULL;
}
ptr = (hcl_bch_t*)hcl_allocmem(hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_bch_t)));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_bch_t*)hak_allocmem(hak, headroom_bytes + ((outlen + 1) * HAK_SIZEOF(hak_bch_t)));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
inlen = ucslen;
ptr = (hcl_bch_t*)((hcl_oob_t*)ptr + headroom_bytes);
hcl_convutobchars (hcl, ucs, &inlen, ptr, &outlen);
ptr = (hak_bch_t*)((hak_oob_t*)ptr + headroom_bytes);
hak_convutobchars (hak, ucs, &inlen, ptr, &outlen);
ptr[outlen] = '\0';
if (bcslen) *bcslen = outlen;
return ptr;
}
hcl_bch_t* hcl_duputobchars (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t ucslen, hcl_oow_t* bcslen)
hak_bch_t* hak_duputobchars (hak_t* hak, const hak_uch_t* ucs, hak_oow_t ucslen, hak_oow_t* bcslen)
{
return hcl_duputobcharswithheadroom (hcl, 0, ucs, ucslen, bcslen);
return hak_duputobcharswithheadroom (hak, 0, ucs, ucslen, bcslen);
}
/* ----------------------------------------------------------------------- */
hcl_uch_t* hcl_dupbtoucstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t* ucslen)
hak_uch_t* hak_dupbtoucstrwithheadroom (hak_t* hak, hak_oow_t headroom_bytes, const hak_bch_t* bcs, hak_oow_t* ucslen)
{
hcl_oow_t inlen, outlen;
hcl_uch_t* ptr;
hak_oow_t inlen, outlen;
hak_uch_t* ptr;
if (hcl_convbtoucstr(hcl, bcs, &inlen, HCL_NULL, &outlen) <= -1)
if (hak_convbtoucstr(hak, bcs, &inlen, HAK_NULL, &outlen) <= -1)
{
/* note it's also an error if no full conversion is made in this function */
return HCL_NULL;
return HAK_NULL;
}
outlen++;
ptr = (hcl_uch_t*)hcl_allocmem(hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_uch_t)));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_uch_t*)hak_allocmem(hak, headroom_bytes + (outlen * HAK_SIZEOF(hak_uch_t)));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
hcl_convbtoucstr (hcl, bcs, &inlen, ptr, &outlen);
hak_convbtoucstr (hak, bcs, &inlen, ptr, &outlen);
if (ucslen) *ucslen = outlen;
return ptr;
}
hcl_uch_t* hcl_dupbtoucstr (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* ucslen)
hak_uch_t* hak_dupbtoucstr (hak_t* hak, const hak_bch_t* bcs, hak_oow_t* ucslen)
{
return hcl_dupbtoucstrwithheadroom (hcl, 0, bcs, ucslen);
return hak_dupbtoucstrwithheadroom (hak, 0, bcs, ucslen);
}
hcl_bch_t* hcl_duputobcstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t* bcslen)
hak_bch_t* hak_duputobcstrwithheadroom (hak_t* hak, hak_oow_t headroom_bytes, const hak_uch_t* ucs, hak_oow_t* bcslen)
{
hcl_oow_t inlen, outlen;
hcl_bch_t* ptr;
hak_oow_t inlen, outlen;
hak_bch_t* ptr;
if (hcl_convutobcstr (hcl, ucs, &inlen, HCL_NULL, &outlen) <= -1)
if (hak_convutobcstr (hak, ucs, &inlen, HAK_NULL, &outlen) <= -1)
{
/* note it's also an error if no full conversion is made in this function */
return HCL_NULL;
return HAK_NULL;
}
outlen++;
ptr = (hcl_bch_t*)hcl_allocmem(hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_bch_t)));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_bch_t*)hak_allocmem(hak, headroom_bytes + (outlen * HAK_SIZEOF(hak_bch_t)));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
ptr = (hcl_bch_t*)((hcl_oob_t*)ptr + headroom_bytes);
ptr = (hak_bch_t*)((hak_oob_t*)ptr + headroom_bytes);
hcl_convutobcstr (hcl, ucs, &inlen, ptr, &outlen);
hak_convutobcstr (hak, ucs, &inlen, ptr, &outlen);
if (bcslen) *bcslen = outlen;
return ptr;
}
hcl_bch_t* hcl_duputobcstr (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* bcslen)
hak_bch_t* hak_duputobcstr (hak_t* hak, const hak_uch_t* ucs, hak_oow_t* bcslen)
{
return hcl_duputobcstrwithheadroom (hcl, 0, ucs, bcslen);
return hak_duputobcstrwithheadroom (hak, 0, ucs, bcslen);
}
/* ----------------------------------------------------------------------- */
hcl_uch_t* hcl_dupuchars (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t ucslen)
hak_uch_t* hak_dupuchars (hak_t* hak, const hak_uch_t* ucs, hak_oow_t ucslen)
{
hcl_uch_t* ptr;
hak_uch_t* ptr;
ptr = (hcl_uch_t*)hcl_allocmem(hcl, (ucslen + 1) * HCL_SIZEOF(hcl_uch_t));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_uch_t*)hak_allocmem(hak, (ucslen + 1) * HAK_SIZEOF(hak_uch_t));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
hcl_copy_uchars (ptr, ucs, ucslen);
hak_copy_uchars (ptr, ucs, ucslen);
ptr[ucslen] = '\0';
return ptr;
}
hcl_bch_t* hcl_dupbchars (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t bcslen)
hak_bch_t* hak_dupbchars (hak_t* hak, const hak_bch_t* bcs, hak_oow_t bcslen)
{
hcl_bch_t* ptr;
hak_bch_t* ptr;
ptr = (hcl_bch_t*)hcl_allocmem(hcl, (bcslen + 1) * HCL_SIZEOF(hcl_bch_t));
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
ptr = (hak_bch_t*)hak_allocmem(hak, (bcslen + 1) * HAK_SIZEOF(hak_bch_t));
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
hcl_copy_bchars (ptr, bcs, bcslen);
hak_copy_bchars (ptr, bcs, bcslen);
ptr[bcslen] = '\0';
return ptr;
}
hcl_uch_t* hcl_dupucstr (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* ucslen)
hak_uch_t* hak_dupucstr (hak_t* hak, const hak_uch_t* ucs, hak_oow_t* ucslen)
{
hcl_oow_t len;
hcl_uch_t* ptr;
hak_oow_t len;
hak_uch_t* ptr;
len = hcl_count_ucstr(ucs);
ptr = hcl_dupuchars(hcl, ucs, len);
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
len = hak_count_ucstr(ucs);
ptr = hak_dupuchars(hak, ucs, len);
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
if (ucslen) *ucslen = len;
return ptr;
}
hcl_bch_t* hcl_dupbcstr (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* bcslen)
hak_bch_t* hak_dupbcstr (hak_t* hak, const hak_bch_t* bcs, hak_oow_t* bcslen)
{
hcl_oow_t len;
hcl_bch_t* ptr;
hak_oow_t len;
hak_bch_t* ptr;
len = hcl_count_bcstr(bcs);
ptr = hcl_dupbchars(hcl, bcs, len);
if (HCL_UNLIKELY(!ptr)) return HCL_NULL;
len = hak_count_bcstr(bcs);
ptr = hak_dupbchars(hak, bcs, len);
if (HAK_UNLIKELY(!ptr)) return HAK_NULL;
if (bcslen) *bcslen = len;
return ptr;
@ -279,19 +279,19 @@ hcl_bch_t* hcl_dupbcstr (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* bcslen)
/* ----------------------------------------------------------------------- */
void hcl_add_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
void hak_add_ntime (hak_ntime_t* z, const hak_ntime_t* x, const hak_ntime_t* y)
{
hcl_ntime_sec_t xs, ys;
hcl_ntime_nsec_t ns;
hak_ntime_sec_t xs, ys;
hak_ntime_nsec_t ns;
/*HCL_ASSERT (x->nsec >= 0 && x->nsec < HCL_NSECS_PER_SEC);
HCL_ASSERT (y->nsec >= 0 && y->nsec < HCL_NSECS_PER_SEC);*/
/*HAK_ASSERT (x->nsec >= 0 && x->nsec < HAK_NSECS_PER_SEC);
HAK_ASSERT (y->nsec >= 0 && y->nsec < HAK_NSECS_PER_SEC);*/
ns = x->nsec + y->nsec;
if (ns >= HCL_NSECS_PER_SEC)
if (ns >= HAK_NSECS_PER_SEC)
{
ns = ns - HCL_NSECS_PER_SEC;
if (x->sec == HCL_TYPE_MAX(hcl_ntime_sec_t))
ns = ns - HAK_NSECS_PER_SEC;
if (x->sec == HAK_TYPE_MAX(hak_ntime_sec_t))
{
if (y->sec >= 0) goto overflow;
xs = x->sec;
@ -309,18 +309,18 @@ void hcl_add_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
ys = y->sec;
}
if ((ys >= 1 && xs > HCL_TYPE_MAX(hcl_ntime_sec_t) - ys) ||
(ys <= -1 && xs < HCL_TYPE_MIN(hcl_ntime_sec_t) - ys))
if ((ys >= 1 && xs > HAK_TYPE_MAX(hak_ntime_sec_t) - ys) ||
(ys <= -1 && xs < HAK_TYPE_MIN(hak_ntime_sec_t) - ys))
{
if (xs >= 0)
{
overflow:
xs = HCL_TYPE_MAX(hcl_ntime_sec_t);
ns = HCL_NSECS_PER_SEC - 1;
xs = HAK_TYPE_MAX(hak_ntime_sec_t);
ns = HAK_NSECS_PER_SEC - 1;
}
else
{
xs = HCL_TYPE_MIN(hcl_ntime_sec_t);
xs = HAK_TYPE_MIN(hak_ntime_sec_t);
ns = 0;
}
}
@ -333,19 +333,19 @@ void hcl_add_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
z->nsec = ns;
}
void hcl_sub_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
void hak_sub_ntime (hak_ntime_t* z, const hak_ntime_t* x, const hak_ntime_t* y)
{
hcl_ntime_sec_t xs, ys;
hcl_ntime_nsec_t ns;
hak_ntime_sec_t xs, ys;
hak_ntime_nsec_t ns;
/*HCL_ASSERT (x->nsec >= 0 && x->nsec < HCL_NSECS_PER_SEC);
HCL_ASSERT (y->nsec >= 0 && y->nsec < HCL_NSECS_PER_SEC);*/
/*HAK_ASSERT (x->nsec >= 0 && x->nsec < HAK_NSECS_PER_SEC);
HAK_ASSERT (y->nsec >= 0 && y->nsec < HAK_NSECS_PER_SEC);*/
ns = x->nsec - y->nsec;
if (ns < 0)
{
ns = ns + HCL_NSECS_PER_SEC;
if (x->sec == HCL_TYPE_MIN(hcl_ntime_sec_t))
ns = ns + HAK_NSECS_PER_SEC;
if (x->sec == HAK_TYPE_MIN(hak_ntime_sec_t))
{
if (y->sec <= 0) goto underflow;
xs = x->sec;
@ -363,18 +363,18 @@ void hcl_sub_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
ys = y->sec;
}
if ((ys >= 1 && xs < HCL_TYPE_MIN(hcl_ntime_sec_t) + ys) ||
(ys <= -1 && xs > HCL_TYPE_MAX(hcl_ntime_sec_t) + ys))
if ((ys >= 1 && xs < HAK_TYPE_MIN(hak_ntime_sec_t) + ys) ||
(ys <= -1 && xs > HAK_TYPE_MAX(hak_ntime_sec_t) + ys))
{
if (xs >= 0)
{
xs = HCL_TYPE_MAX(hcl_ntime_sec_t);
ns = HCL_NSECS_PER_SEC - 1;
xs = HAK_TYPE_MAX(hak_ntime_sec_t);
ns = HAK_NSECS_PER_SEC - 1;
}
else
{
underflow:
xs = HCL_TYPE_MIN(hcl_ntime_sec_t);
xs = HAK_TYPE_MIN(hak_ntime_sec_t);
ns = 0;
}
}
@ -389,26 +389,26 @@ void hcl_sub_ntime (hcl_ntime_t* z, const hcl_ntime_t* x, const hcl_ntime_t* y)
/* ----------------------------------------------------------------------- */
const hcl_bch_t* hcl_get_base_name_from_bcstr_path (const hcl_bch_t* path)
const hak_bch_t* hak_get_base_name_from_bcstr_path (const hak_bch_t* path)
{
const hcl_bch_t* p, * last = HCL_NULL;
const hak_bch_t* p, * last = HAK_NULL;
for (p = path; *p != '\0'; p++)
{
if (HCL_IS_PATH_SEP(*p)) last = p;
if (HAK_IS_PATH_SEP(*p)) last = p;
}
return (last == HCL_NULL)? path: (last + 1);
return (last == HAK_NULL)? path: (last + 1);
}
const hcl_uch_t* hcl_get_base_name_from_ucstr_path (const hcl_uch_t* path)
const hak_uch_t* hak_get_base_name_from_ucstr_path (const hak_uch_t* path)
{
const hcl_uch_t* p, * last = HCL_NULL;
const hak_uch_t* p, * last = HAK_NULL;
for (p = path; *p != '\0'; p++)
{
if (HCL_IS_PATH_SEP(*p)) last = p;
if (HAK_IS_PATH_SEP(*p)) last = p;
}
return (last == HCL_NULL)? path: (last + 1);
return (last == HAK_NULL)? path: (last + 1);
}