#ifndef PERL_OBJECT
static void hsplit _((HV *hv));
static void hfreeentries _((HV *hv));
-static HE* more_he _((void));
+static void more_he _((void));
+#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)*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 *
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')) {
|| (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;
}
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')) {
|| (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;
}
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;
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);
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;
I32 oldsize = (I32) xhv->xhv_max + 1; /* sic(k) */
register I32 newsize = oldsize * 2;
register I32 i;
- register HE **a = (HE**)xhv->xhv_array;
- register HE **b;
+ register char *a = xhv->xhv_array;
+ register HE **aep;
+ register HE **bep;
register HE *entry;
register HE **oentry;
- nomemok = TRUE;
+ PL_nomemok = TRUE;
#if defined(STRANGE_MALLOC) || defined(MYMALLOC)
- Renew(a, newsize, HE*);
+ Renew(a, ARRAY_ALLOC_BYTES(newsize), char);
if (!a) {
- nomemok = FALSE;
+ PL_nomemok = FALSE;
return;
}
#else
#define MALLOC_OVERHEAD 16
- New(2, a, newsize*sizeof(HE*) * 2 - MALLOC_OVERHEAD, char);
+ 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; i<oldsize; i++,a++) {
- if (!*a) /* non-existent */
+ for (i=0; i<oldsize; i++,aep++) {
+ if (!*aep) /* non-existent */
continue;
- b = a+oldsize;
- for (oentry = a, entry = *a; entry; entry = *oentry) {
+ bep = aep+oldsize;
+ for (oentry = aep, entry = *aep; entry; entry = *oentry) {
if ((HeHASH(entry) & newsize) != i) {
*oentry = HeNEXT(entry);
- HeNEXT(entry) = *b;
- if (!*b)
+ HeNEXT(entry) = *bep;
+ if (!*bep)
xhv->xhv_fill++;
- *b = entry;
+ *bep = entry;
continue;
}
else
oentry = &HeNEXT(entry);
}
- if (!*a) /* everything moved */
+ if (!*aep) /* everything moved */
xhv->xhv_fill--;
}
}
register I32 newsize;
register I32 i;
register I32 j;
- register HE **a;
+ register char *a;
+ register HE **aep;
register HE *entry;
register HE **oentry;
if (newsize < newmax)
return; /* overflow detection */
- a = (HE**)xhv->xhv_array;
+ a = xhv->xhv_array;
if (a) {
- nomemok = TRUE;
+ PL_nomemok = TRUE;
#if defined(STRANGE_MALLOC) || defined(MYMALLOC)
- Renew(a, newsize, HE*);
+ Renew(a, ARRAY_ALLOC_BYTES(newsize), char);
if (!a) {
- nomemok = FALSE;
+ PL_nomemok = FALSE;
return;
}
#else
- New(2, a, newsize * sizeof(HE*) * 2 - MALLOC_OVERHEAD, char);
+ 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 {
-#if defined(STRANGE_MALLOC) || defined(MYMALLOC)
- Newz(0, a, newsize, HE*);
-#else
- Newz(0, a, newsize * sizeof(HE*) * 2 - MALLOC_OVERHEAD, char);
-#endif
+ 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; i<oldsize; i++,a++) {
- if (!*a) /* non-existent */
+ aep = (HE**)a;
+ for (i=0; i<oldsize; i++,aep++) {
+ if (!*aep) /* non-existent */
continue;
- for (oentry = a, entry = *a; entry; entry = *oentry) {
+ for (oentry = aep, entry = *aep; entry; entry = *oentry) {
if ((j = (HeHASH(entry) & newsize)) != i) {
j -= i;
*oentry = HeNEXT(entry);
- if (!(HeNEXT(entry) = a[j]))
+ if (!(HeNEXT(entry) = aep[j]))
xhv->xhv_fill++;
- a[j] = entry;
+ aep[j] = entry;
continue;
}
else
oentry = &HeNEXT(entry);
}
- if (!*a) /* everything moved */
+ if (!*aep) /* everything moved */
xhv->xhv_fill--;
}
}
return hv;
#if 0
- if (!SvRMAGICAL(ohv) || !mg_find((SV*)ohv,'P')) {
+ if (! SvTIED_mg((SV*)ohv, 'P')) {
/* Quick way ???*/
}
else
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));
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));
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));
}
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) {
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 */
}
break;
}
+ UNLOCK_STRTAB_MUTEX;
if (!found)
warn("Attempt to free non-existent shared string");
/* 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 */
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);
}