X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=hv.c;h=0c472bcda54737f90e36ef258786ec4c7ccabe92;hb=697943021785eb8447e25eb51a6f27fd78921863;hp=463cf301a3cfe364056e4d7a0133371ecf9ee628;hpb=ba3eb2af450c2577c20a691fb686a5e02955c48b;p=p5sagit%2Fp5-mst-13.2.git diff --git a/hv.c b/hv.c index 463cf30..0c472bc 100644 --- a/hv.c +++ b/hv.c @@ -1,6 +1,6 @@ /* hv.c * - * Copyright (c) 1991-1997, Larry Wall + * Copyright (c) 1991-1999, Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -18,46 +18,58 @@ static void hv_magic_check _((HV *hv, bool *needs_copy, bool *needs_store)); #ifndef PERL_OBJECT static void hsplit _((HV *hv)); static void hfreeentries _((HV *hv)); -static HE* more_he _((void)); +static void more_he _((void)); +static HEK *save_hek _((const char *str, I32 len, U32 hash)); +#endif + +#if defined(STRANGE_MALLOC) || defined(MYMALLOC) +# define ARRAY_ALLOC_BYTES(size) ( (size)*sizeof(HE*) ) +#else +# define MALLOC_OVERHEAD 16 +# define ARRAY_ALLOC_BYTES(size) ( ((size) < 64) \ + ? (size)*sizeof(HE*) \ + : (size)*sizeof(HE*)*2 - MALLOC_OVERHEAD ) #endif STATIC HE* new_he(void) { HE* he; - if (he_root) { - he = he_root; - he_root = HeNEXT(he); - return he; - } - return more_he(); + LOCK_SV_MUTEX; + if (!PL_he_root) + more_he(); + he = PL_he_root; + PL_he_root = HeNEXT(he); + UNLOCK_SV_MUTEX; + return he; } STATIC void del_he(HE *p) { - HeNEXT(p) = (HE*)he_root; - he_root = p; + LOCK_SV_MUTEX; + HeNEXT(p) = (HE*)PL_he_root; + PL_he_root = p; + UNLOCK_SV_MUTEX; } -STATIC HE* +STATIC void more_he(void) { register HE* he; register HE* heend; - New(54, he_root, 1008/sizeof(HE), HE); - he = he_root; + New(54, PL_he_root, 1008/sizeof(HE), HE); + he = PL_he_root; heend = &he[1008 / sizeof(HE) - 1]; while (he < heend) { HeNEXT(he) = (HE*)(he + 1); he++; } HeNEXT(he) = 0; - return new_he(); } STATIC HEK * -save_hek(char *str, I32 len, U32 hash) +save_hek(const char *str, I32 len, U32 hash) { char *k; register HEK *hek; @@ -81,7 +93,7 @@ unshare_hek(HEK *hek) * contains an SV* */ SV** -hv_fetch(HV *hv, char *key, U32 klen, I32 lval) +hv_fetch(HV *hv, const char *key, U32 klen, I32 lval) { register XPVHV* xhv; register U32 hash; @@ -96,15 +108,15 @@ hv_fetch(HV *hv, char *key, U32 klen, I32 lval) dTHR; sv = sv_newmortal(); mg_copy((SV*)hv, sv, key, klen); - hv_fetch_sv = sv; - return &hv_fetch_sv; + PL_hv_fetch_sv = sv; + return &PL_hv_fetch_sv; } #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { U32 i; for (i = 0; i < klen; ++i) if (isLOWER(key[i])) { - char *nkey = strupr(SvPVX(sv_2mortal(newSVpv(key,klen)))); + char *nkey = strupr(SvPVX(sv_2mortal(newSVpvn(key,klen)))); SV **ret = hv_fetch(hv, nkey, klen, 0); if (!ret && lval) ret = hv_store(hv, key, klen, NEWSV(61,0), 0); @@ -121,7 +133,7 @@ hv_fetch(HV *hv, char *key, U32 klen, I32 lval) || (HvNAME(hv) && strEQ(HvNAME(hv),ENV_HV_NAME)) #endif ) - Newz(503,xhv->xhv_array, sizeof(HE*) * (xhv->xhv_max + 1), char); + Newz(503,xhv->xhv_array, ARRAY_ALLOC_BYTES(xhv->xhv_max + 1), char); else return 0; } @@ -140,13 +152,13 @@ hv_fetch(HV *hv, char *key, U32 klen, I32 lval) } #ifdef DYNAMIC_ENV_FETCH /* %ENV lookup? If so, try to fetch the value now */ if (HvNAME(hv) && strEQ(HvNAME(hv),ENV_HV_NAME)) { - char *gotenv; - - if ((gotenv = PerlEnv_getenv(key)) != Nullch) { - sv = newSVpv(gotenv,strlen(gotenv)); - SvTAINTED_on(sv); - return hv_store(hv,key,klen,sv,hash); - } + unsigned long len; + char *env = PerlEnv_ENVgetenv_len(key,&len); + if (env) { + sv = newSVpvn(env,len); + SvTAINTED_on(sv); + return hv_store(hv,key,klen,sv,hash); + } } #endif if (lval) { /* gonna assign to this, so it better be there */ @@ -176,14 +188,14 @@ hv_fetch_ent(HV *hv, SV *keysv, I32 lval, register U32 hash) sv = sv_newmortal(); keysv = sv_2mortal(newSVsv(keysv)); mg_copy((SV*)hv, sv, (char*)keysv, HEf_SVKEY); - if (!HeKEY_hek(&hv_fetch_ent_mh)) { + if (!HeKEY_hek(&PL_hv_fetch_ent_mh)) { char *k; New(54, k, HEK_BASESIZE + sizeof(SV*), char); - HeKEY_hek(&hv_fetch_ent_mh) = (HEK*)k; + HeKEY_hek(&PL_hv_fetch_ent_mh) = (HEK*)k; } - HeSVKEY_set(&hv_fetch_ent_mh, keysv); - HeVAL(&hv_fetch_ent_mh) = sv; - return &hv_fetch_ent_mh; + HeSVKEY_set(&PL_hv_fetch_ent_mh, keysv); + HeVAL(&PL_hv_fetch_ent_mh) = sv; + return &PL_hv_fetch_ent_mh; } #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { @@ -191,7 +203,7 @@ hv_fetch_ent(HV *hv, SV *keysv, I32 lval, register U32 hash) key = SvPV(keysv, klen); for (i = 0; i < klen; ++i) if (isLOWER(key[i])) { - SV *nkeysv = sv_2mortal(newSVpv(key,klen)); + SV *nkeysv = sv_2mortal(newSVpvn(key,klen)); (void)strupr(SvPVX(nkeysv)); entry = hv_fetch_ent(hv, nkeysv, 0, 0); if (!entry && lval) @@ -209,7 +221,7 @@ hv_fetch_ent(HV *hv, SV *keysv, I32 lval, register U32 hash) || (HvNAME(hv) && strEQ(HvNAME(hv),ENV_HV_NAME)) #endif ) - Newz(503,xhv->xhv_array, sizeof(HE*) * (xhv->xhv_max + 1), char); + Newz(503,xhv->xhv_array, ARRAY_ALLOC_BYTES(xhv->xhv_max + 1), char); else return 0; } @@ -231,13 +243,13 @@ hv_fetch_ent(HV *hv, SV *keysv, I32 lval, register U32 hash) } #ifdef DYNAMIC_ENV_FETCH /* %ENV lookup? If so, try to fetch the value now */ if (HvNAME(hv) && strEQ(HvNAME(hv),ENV_HV_NAME)) { - char *gotenv; - - if ((gotenv = PerlEnv_getenv(key)) != Nullch) { - sv = newSVpv(gotenv,strlen(gotenv)); - SvTAINTED_on(sv); - return hv_store_ent(hv,keysv,sv,hash); - } + unsigned long len; + char *env = PerlEnv_ENVgetenv_len(key,&len); + if (env) { + sv = newSVpvn(env,len); + SvTAINTED_on(sv); + return hv_store_ent(hv,keysv,sv,hash); + } } #endif if (lval) { /* gonna assign to this, so it better be there */ @@ -267,7 +279,7 @@ hv_magic_check (HV *hv, bool *needs_copy, bool *needs_store) } SV** -hv_store(HV *hv, char *key, U32 klen, SV *val, register U32 hash) +hv_store(HV *hv, const char *key, U32 klen, SV *val, register U32 hash) { register XPVHV* xhv; register I32 i; @@ -288,7 +300,7 @@ hv_store(HV *hv, char *key, U32 klen, SV *val, register U32 hash) return 0; #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { - SV *sv = sv_2mortal(newSVpv(key,klen)); + SV *sv = sv_2mortal(newSVpvn(key,klen)); key = strupr(SvPVX(sv)); hash = 0; } @@ -299,7 +311,7 @@ hv_store(HV *hv, char *key, U32 klen, SV *val, register U32 hash) PERL_HASH(hash, key, klen); if (!xhv->xhv_array) - Newz(505, xhv->xhv_array, sizeof(HE**) * (xhv->xhv_max + 1), char); + Newz(505, xhv->xhv_array, ARRAY_ALLOC_BYTES(xhv->xhv_max + 1), char); oentry = &((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; i = 1; @@ -355,9 +367,9 @@ hv_store_ent(HV *hv, SV *keysv, SV *val, register U32 hash) bool needs_store; hv_magic_check (hv, &needs_copy, &needs_store); if (needs_copy) { - bool save_taint = tainted; - if (tainting) - tainted = SvTAINTED(keysv); + bool save_taint = PL_tainted; + if (PL_tainting) + PL_tainted = SvTAINTED(keysv); keysv = sv_2mortal(newSVsv(keysv)); mg_copy((SV*)hv, val, (char*)keysv, HEf_SVKEY); TAINT_IF(save_taint); @@ -366,7 +378,7 @@ hv_store_ent(HV *hv, SV *keysv, SV *val, register U32 hash) #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { key = SvPV(keysv, klen); - keysv = sv_2mortal(newSVpv(key,klen)); + keysv = sv_2mortal(newSVpvn(key,klen)); (void)strupr(SvPVX(keysv)); hash = 0; } @@ -380,7 +392,7 @@ hv_store_ent(HV *hv, SV *keysv, SV *val, register U32 hash) PERL_HASH(hash, key, klen); if (!xhv->xhv_array) - Newz(505, xhv->xhv_array, sizeof(HE**) * (xhv->xhv_max + 1), char); + Newz(505, xhv->xhv_array, ARRAY_ALLOC_BYTES(xhv->xhv_max + 1), char); oentry = &((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; i = 1; @@ -417,7 +429,7 @@ hv_store_ent(HV *hv, SV *keysv, SV *val, register U32 hash) } SV * -hv_delete(HV *hv, char *key, U32 klen, I32 flags) +hv_delete(HV *hv, const char *key, U32 klen, I32 flags) { register XPVHV* xhv; register I32 i; @@ -446,7 +458,7 @@ hv_delete(HV *hv, char *key, U32 klen, I32 flags) } #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { - sv = sv_2mortal(newSVpv(key,klen)); + sv = sv_2mortal(newSVpvn(key,klen)); key = strupr(SvPVX(sv)); } #endif @@ -516,7 +528,7 @@ hv_delete_ent(HV *hv, SV *keysv, I32 flags, U32 hash) #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { key = SvPV(keysv, klen); - keysv = sv_2mortal(newSVpv(key,klen)); + keysv = sv_2mortal(newSVpvn(key,klen)); (void)strupr(SvPVX(keysv)); hash = 0; } @@ -560,7 +572,7 @@ hv_delete_ent(HV *hv, SV *keysv, I32 flags, U32 hash) } bool -hv_exists(HV *hv, char *key, U32 klen) +hv_exists(HV *hv, const char *key, U32 klen) { register XPVHV* xhv; register U32 hash; @@ -580,18 +592,24 @@ hv_exists(HV *hv, char *key, U32 klen) } #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { - sv = sv_2mortal(newSVpv(key,klen)); + sv = sv_2mortal(newSVpvn(key,klen)); key = strupr(SvPVX(sv)); } #endif } xhv = (XPVHV*)SvANY(hv); +#ifndef DYNAMIC_ENV_FETCH if (!xhv->xhv_array) return 0; +#endif PERL_HASH(hash, key, klen); +#ifdef DYNAMIC_ENV_FETCH + if (!xhv->xhv_array) entry = Null(HE*); + else +#endif entry = ((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; for (; entry; entry = HeNEXT(entry)) { if (HeHASH(entry) != hash) /* strings can't be equal */ @@ -602,6 +620,18 @@ hv_exists(HV *hv, char *key, U32 klen) continue; return TRUE; } +#ifdef DYNAMIC_ENV_FETCH /* is it out there? */ + if (HvNAME(hv) && strEQ(HvNAME(hv), ENV_HV_NAME)) { + unsigned long len; + char *env = PerlEnv_ENVgetenv_len(key,&len); + if (env) { + sv = newSVpvn(env,len); + SvTAINTED_on(sv); + (void)hv_store(hv,key,klen,sv,hash); + return TRUE; + } + } +#endif return FALSE; } @@ -630,7 +660,7 @@ hv_exists_ent(HV *hv, SV *keysv, U32 hash) #ifdef ENV_IS_CASELESS else if (mg_find((SV*)hv,'E')) { key = SvPV(keysv, klen); - keysv = sv_2mortal(newSVpv(key,klen)); + keysv = sv_2mortal(newSVpvn(key,klen)); (void)strupr(SvPVX(keysv)); hash = 0; } @@ -638,13 +668,19 @@ hv_exists_ent(HV *hv, SV *keysv, U32 hash) } xhv = (XPVHV*)SvANY(hv); +#ifndef DYNAMIC_ENV_FETCH if (!xhv->xhv_array) return 0; +#endif key = SvPV(keysv, klen); if (!hash) PERL_HASH(hash, key, klen); +#ifdef DYNAMIC_ENV_FETCH + if (!xhv->xhv_array) entry = Null(HE*); + else +#endif entry = ((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; for (; entry; entry = HeNEXT(entry)) { if (HeHASH(entry) != hash) /* strings can't be equal */ @@ -655,6 +691,18 @@ hv_exists_ent(HV *hv, SV *keysv, U32 hash) continue; return TRUE; } +#ifdef DYNAMIC_ENV_FETCH /* is it out there? */ + if (HvNAME(hv) && strEQ(HvNAME(hv), ENV_HV_NAME)) { + unsigned long len; + char *env = PerlEnv_ENVgetenv_len(key,&len); + if (env) { + sv = newSVpvn(env,len); + SvTAINTED_on(sv); + (void)hv_store_ent(hv,keysv,sv,hash); + return TRUE; + } + } +#endif return FALSE; } @@ -665,67 +713,57 @@ hsplit(HV *hv) I32 oldsize = (I32) xhv->xhv_max + 1; /* sic(k) */ register I32 newsize = oldsize * 2; register I32 i; - register HE **a; - register HE **b; + register char *a = xhv->xhv_array; + register HE **aep; + register HE **bep; register HE *entry; register HE **oentry; -#ifndef STRANGE_MALLOC - I32 tmp; -#endif - a = (HE**)xhv->xhv_array; - nomemok = TRUE; -#ifdef STRANGE_MALLOC - Renew(a, newsize, HE*); + PL_nomemok = TRUE; +#if defined(STRANGE_MALLOC) || defined(MYMALLOC) + Renew(a, ARRAY_ALLOC_BYTES(newsize), char); if (!a) { - nomemok = FALSE; + PL_nomemok = FALSE; return; } #else - i = newsize * sizeof(HE*); #define MALLOC_OVERHEAD 16 - tmp = MALLOC_OVERHEAD; - while (tmp - MALLOC_OVERHEAD < i) - tmp += tmp; - tmp -= MALLOC_OVERHEAD; - tmp /= sizeof(HE*); - assert(tmp >= newsize); - New(2,a, tmp, HE*); + New(2, a, ARRAY_ALLOC_BYTES(newsize), char); if (!a) { - nomemok = FALSE; + PL_nomemok = FALSE; return; } - Copy(xhv->xhv_array, a, oldsize, HE*); + Copy(xhv->xhv_array, a, oldsize * sizeof(HE*), char); if (oldsize >= 64) { - offer_nice_chunk(xhv->xhv_array, - oldsize * sizeof(HE*) * 2 - MALLOC_OVERHEAD); + offer_nice_chunk(xhv->xhv_array, ARRAY_ALLOC_BYTES(oldsize)); } else Safefree(xhv->xhv_array); #endif - nomemok = FALSE; - Zero(&a[oldsize], oldsize, HE*); /* zero 2nd half*/ + PL_nomemok = FALSE; + Zero(&a[oldsize * sizeof(HE*)], (newsize-oldsize) * sizeof(HE*), char); /* zero 2nd half*/ xhv->xhv_max = --newsize; - xhv->xhv_array = (char*)a; + xhv->xhv_array = a; + aep = (HE**)a; - for (i=0; ixhv_fill++; - *b = entry; + *bep = entry; continue; } else oentry = &HeNEXT(entry); } - if (!*a) /* everything moved */ + if (!*aep) /* everything moved */ xhv->xhv_fill--; } } @@ -738,7 +776,8 @@ hv_ksplit(HV *hv, IV newmax) register I32 newsize; register I32 i; register I32 j; - register HE **a; + register char *a; + register HE **aep; register HE *entry; register HE **oentry; @@ -753,63 +792,56 @@ hv_ksplit(HV *hv, IV newmax) if (newsize < newmax) return; /* overflow detection */ - a = (HE**)xhv->xhv_array; + a = xhv->xhv_array; if (a) { - nomemok = TRUE; -#ifdef STRANGE_MALLOC - Renew(a, newsize, HE*); + PL_nomemok = TRUE; +#if defined(STRANGE_MALLOC) || defined(MYMALLOC) + Renew(a, ARRAY_ALLOC_BYTES(newsize), char); if (!a) { - nomemok = FALSE; + PL_nomemok = FALSE; return; } #else - i = newsize * sizeof(HE*); - j = MALLOC_OVERHEAD; - while (j - MALLOC_OVERHEAD < i) - j += j; - j -= MALLOC_OVERHEAD; - j /= sizeof(HE*); - assert(j >= newsize); - New(2, a, j, HE*); + New(2, a, ARRAY_ALLOC_BYTES(newsize), char); if (!a) { - nomemok = FALSE; + PL_nomemok = FALSE; return; } - Copy(xhv->xhv_array, a, oldsize, HE*); + Copy(xhv->xhv_array, a, oldsize * sizeof(HE*), char); if (oldsize >= 64) { - offer_nice_chunk(xhv->xhv_array, - oldsize * sizeof(HE*) * 2 - MALLOC_OVERHEAD); + offer_nice_chunk(xhv->xhv_array, ARRAY_ALLOC_BYTES(oldsize)); } else Safefree(xhv->xhv_array); #endif - nomemok = FALSE; - Zero(&a[oldsize], newsize-oldsize, HE*); /* zero 2nd half*/ + PL_nomemok = FALSE; + Zero(&a[oldsize * sizeof(HE*)], (newsize-oldsize) * sizeof(HE*), char); /* zero 2nd half*/ } else { - Newz(0, a, newsize, HE*); + Newz(0, a, ARRAY_ALLOC_BYTES(newsize), char); } xhv->xhv_max = --newsize; - xhv->xhv_array = (char*)a; + xhv->xhv_array = a; if (!xhv->xhv_fill) /* skip rest if no entries */ return; - for (i=0; ixhv_fill++; - a[j] = entry; + aep[j] = entry; continue; } else oentry = &HeNEXT(entry); } - if (!*a) /* everything moved */ + if (!*aep) /* everything moved */ xhv->xhv_fill--; } } @@ -835,6 +867,44 @@ newHV(void) return hv; } +HV * +newHVhv(HV *ohv) +{ + register HV *hv; + STRLEN hv_max = ohv ? HvMAX(ohv) : 0; + STRLEN hv_fill = ohv ? HvFILL(ohv) : 0; + + hv = newHV(); + while (hv_max && hv_max + 1 >= hv_fill * 2) + hv_max = hv_max / 2; /* Is always 2^n-1 */ + HvMAX(hv) = hv_max; + if (!hv_fill) + return hv; + +#if 0 + if (! SvTIED_mg((SV*)ohv, 'P')) { + /* Quick way ???*/ + } + else +#endif + { + HE *entry; + I32 hv_riter = HvRITER(ohv); /* current root of iterator */ + HE *hv_eiter = HvEITER(ohv); /* current entry of iterator */ + + /* Slow way */ + hv_iterinit(ohv); + while (entry = hv_iternext(ohv)) { + hv_store(hv, HeKEY(entry), HeKLEN(entry), + SvREFCNT_inc(HeVAL(entry)), HeHASH(entry)); + } + HvRITER(ohv) = hv_riter; + HvEITER(ohv) = hv_eiter; + } + + return hv; +} + void hv_free_ent(HV *hv, register HE *entry) { @@ -844,7 +914,7 @@ hv_free_ent(HV *hv, register HE *entry) return; val = HeVAL(entry); if (val && isGV(val) && GvCVu(val) && HvNAME(hv)) - sub_generation++; /* may be deletion of method from stash */ + PL_sub_generation++; /* may be deletion of method from stash */ SvREFCNT_dec(val); if (HeKLEN(entry) == HEf_SVKEY) { SvREFCNT_dec(HeKEY_sv(entry)); @@ -863,7 +933,7 @@ hv_delayfree_ent(HV *hv, register HE *entry) if (!entry) return; if (isGV(HeVAL(entry)) && GvCVu(HeVAL(entry)) && HvNAME(hv)) - sub_generation++; /* may be deletion of method from stash */ + PL_sub_generation++; /* may be deletion of method from stash */ sv_2mortal(HeVAL(entry)); /* free between statements */ if (HeKLEN(entry) == HEf_SVKEY) { sv_2mortal(HeKEY_sv(entry)); @@ -958,17 +1028,13 @@ hv_iterinit(HV *hv) croak("Bad hash"); xhv = (XPVHV*)SvANY(hv); entry = xhv->xhv_eiter; -#ifdef DYNAMIC_ENV_FETCH /* set up %ENV for iteration */ - if (HvNAME(hv) && strEQ(HvNAME(hv), ENV_HV_NAME)) - prime_env_iter(); -#endif if (entry && HvLAZYDEL(hv)) { /* was deleted earlier? */ HvLAZYDEL_off(hv); hv_free_ent(hv, entry); } xhv->xhv_riter = -1; xhv->xhv_eiter = Null(HE*); - return xhv->xhv_fill; /* should be xhv->xhv_keys? May change later */ + return xhv->xhv_keys; /* used to be xhv->xhv_fill before 5.004_65 */ } HE * @@ -984,7 +1050,7 @@ hv_iternext(HV *hv) xhv = (XPVHV*)SvANY(hv); oldentry = entry = xhv->xhv_eiter; - if (SvRMAGICAL(hv) && (mg = mg_find((SV*)hv,'P'))) { + if (mg = SvTIED_mg((SV*)hv, 'P')) { SV *key = sv_newmortal(); if (entry) { sv_setsv(key, HeSVKEY_force(entry)); @@ -1014,9 +1080,13 @@ hv_iternext(HV *hv) xhv->xhv_eiter = Null(HE*); return Null(HE*); } +#ifdef DYNAMIC_ENV_FETCH /* set up %ENV for iteration */ + if (!entry && HvNAME(hv) && strEQ(HvNAME(hv), ENV_HV_NAME)) + prime_env_iter(); +#endif if (!xhv->xhv_array) - Newz(506,xhv->xhv_array, sizeof(HE*) * (xhv->xhv_max + 1), char); + Newz(506,xhv->xhv_array, ARRAY_ALLOC_BYTES(xhv->xhv_max + 1), char); if (entry) entry = HeNEXT(entry); while (!entry) { @@ -1059,7 +1129,7 @@ hv_iterkeysv(register HE *entry) if (HeKLEN(entry) == HEf_SVKEY) return sv_mortalcopy(HeKEY_sv(entry)); else - return sv_2mortal(newSVpv((HeKLEN(entry) ? HeKEY(entry) : ""), + return sv_2mortal(newSVpvn((HeKLEN(entry) ? HeKEY(entry) : ""), HeKLEN(entry))); } @@ -1095,7 +1165,7 @@ hv_magic(HV *hv, GV *gv, int how) } char* -sharepvn(char *sv, I32 len, U32 hash) +sharepvn(const char *sv, I32 len, U32 hash) { return HEK_KEY(share_hek(sv, len, hash)); } @@ -1104,7 +1174,7 @@ sharepvn(char *sv, I32 len, U32 hash) * len and hash must both be valid for str. */ void -unsharepvn(char *str, I32 len, U32 hash) +unsharepvn(const char *str, I32 len, U32 hash) { register XPVHV* xhv; register HE *entry; @@ -1113,12 +1183,13 @@ unsharepvn(char *str, I32 len, U32 hash) I32 found = 0; /* what follows is the moral equivalent of: - if ((Svp = hv_fetch(strtab, tmpsv, FALSE, hash))) { + if ((Svp = hv_fetch(PL_strtab, tmpsv, FALSE, hash))) { if (--*Svp == Nullsv) - hv_delete(strtab, str, len, G_DISCARD, hash); + hv_delete(PL_strtab, str, len, G_DISCARD, hash); } */ - xhv = (XPVHV*)SvANY(strtab); + xhv = (XPVHV*)SvANY(PL_strtab); /* assert(xhv_array != 0) */ + LOCK_STRTAB_MUTEX; oentry = &((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; for (entry = *oentry; entry; i=0, oentry = &HeNEXT(entry), entry = *oentry) { if (HeHASH(entry) != hash) /* strings can't be equal */ @@ -1138,6 +1209,7 @@ unsharepvn(char *str, I32 len, U32 hash) } break; } + UNLOCK_STRTAB_MUTEX; if (!found) warn("Attempt to free non-existent shared string"); @@ -1148,7 +1220,7 @@ unsharepvn(char *str, I32 len, U32 hash) * len and hash must both be valid for str. */ HEK * -share_hek(char *str, I32 len, register U32 hash) +share_hek(const char *str, I32 len, register U32 hash) { register XPVHV* xhv; register HE *entry; @@ -1158,11 +1230,12 @@ share_hek(char *str, I32 len, register U32 hash) /* what follows is the moral equivalent of: - if (!(Svp = hv_fetch(strtab, str, len, FALSE))) - hv_store(strtab, str, len, Nullsv, hash); + if (!(Svp = hv_fetch(PL_strtab, str, len, FALSE))) + hv_store(PL_strtab, str, len, Nullsv, hash); */ - xhv = (XPVHV*)SvANY(strtab); + xhv = (XPVHV*)SvANY(PL_strtab); /* assert(xhv_array != 0) */ + LOCK_STRTAB_MUTEX; oentry = &((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max]; for (entry = *oentry; entry; i=0, entry = HeNEXT(entry)) { if (HeHASH(entry) != hash) /* strings can't be equal */ @@ -1184,11 +1257,12 @@ share_hek(char *str, I32 len, register U32 hash) if (i) { /* initial entry? */ ++xhv->xhv_fill; if (xhv->xhv_keys > xhv->xhv_max) - hsplit(strtab); + hsplit(PL_strtab); } } ++HeVAL(entry); /* use value slot as REFCNT */ + UNLOCK_STRTAB_MUTEX; return HeKEY_hek(entry); }