Lines Matching refs:entry
239 compute it. The return value is the new hash entry so created. It will be
351 Returns the hash entry which corresponds to the specified key in the hash.
378 HE *entry;
418 entry = PL_hv_fetch_ent_mh;
419 if (entry)
420 PL_hv_fetch_ent_mh = HeNEXT(entry);
423 entry = new_HE();
425 HeKEY_hek(entry) = (HEK*)k;
427 HeNEXT(entry) = Nullhe;
428 HeSVKEY_set(entry, keysv);
429 HeVAL(entry) = sv;
432 /* so we can free entry when freeing sv */
433 LvTARG(sv) = (SV*)entry;
439 return entry;
451 entry = hv_fetch_common(hv, Nullsv, nkey, klen,
456 if (!entry && (action & HV_FETCH_LVALUE)) {
460 entry = hv_fetch_common(hv, keysv, key, klen,
467 return entry;
623 if (!xhv->xhv_array /* !HvARRAY(hv) */) entry = Null(HE*);
627 /* entry = (HvARRAY(hv))[hash & (I32) HvMAX(hv)]; */
628 entry = ((HE**)xhv->xhv_array)[hash & (I32) xhv->xhv_max];
630 for (; entry; ++n_links, entry = HeNEXT(entry)) {
631 if (HeHASH(entry) != hash) /* strings can't be equal */
633 if (HeKLEN(entry) != (I32)klen)
635 if (HeKEY(entry) != key && memNE(HeKEY(entry),key,klen)) /* is this it? */
637 if ((HeKFLAGS(entry) ^ masked_flags) & HVhek_UTF8)
641 if (HeKFLAGS(entry) != masked_flags) {
643 match. But if entry was set previously with HVhek_WASUTF8
652 unshare_hek (HeKEY_hek(entry));
653 HeKEY_hek(entry) = new_hek;
656 HeKFLAGS(entry) = masked_flags;
660 if (HeVAL(entry) == &PL_sv_placeholder) {
683 HeVAL(entry) = val;
685 SvREFCNT_dec(HeVAL(entry));
686 HeVAL(entry) = val;
688 } else if (HeVAL(entry) == &PL_sv_placeholder) {
695 return entry;
711 if (!entry && SvREADONLY(hv) && !(action & HV_FETCH_ISEXISTS)) {
749 entry = new_HE();
753 HeKEY_hek(entry) = share_hek_flags(key, klen, hash, flags);
755 HeKEY_hek(entry) = save_hek_flags(key, klen, hash, flags);
756 HeVAL(entry) = val;
757 HeNEXT(entry) = *oentry;
758 *oentry = entry;
766 if (!n_links) { /* initial entry? */
774 number of buckets on every entry. Linear search feels a less worse
779 return entry;
879 register HE *entry;
904 entry = hv_fetch_common(hv, keysv, key, klen,
907 sv = entry ? HeVAL(entry) : NULL;
977 entry = *oentry;
979 for (; entry; i=0, oentry = &HeNEXT(entry), entry = *oentry) {
980 if (HeHASH(entry) != hash) /* strings can't be equal */
982 if (HeKLEN(entry) != (I32)klen)
984 if (HeKEY(entry) != key && memNE(HeKEY(entry),key,klen)) /* is this it? */
986 if ((HeKFLAGS(entry) ^ masked_flags) & HVhek_UTF8)
990 if (HeVAL(entry) == &PL_sv_placeholder)
996 else if (SvREADONLY(hv) && HeVAL(entry) && SvREADONLY(HeVAL(entry))) {
1007 sv = sv_2mortal(HeVAL(entry));
1008 HeVAL(entry) = &PL_sv_placeholder;
1012 * If a restricted hash, rather than really deleting the entry, put
1018 SvREFCNT_dec(HeVAL(entry));
1019 HeVAL(entry) = &PL_sv_placeholder;
1024 *oentry = HeNEXT(entry);
1027 if (entry == xhv->xhv_eiter /* HvEITER(hv) */)
1030 hv_free_ent(hv, entry);
1058 register HE *entry;
1109 for (oentry = aep, entry = *aep; entry; entry = *oentry) {
1110 if ((HeHASH(entry) & newsize) != (U32)i) {
1111 *oentry = HeNEXT(entry);
1112 HeNEXT(entry) = *bep;
1115 *bep = entry;
1120 oentry = &HeNEXT(entry);
1163 entry = *aep;
1164 while (entry) {
1167 HE *next = HeNEXT(entry);
1171 PERL_HASH_INTERNAL(hash, HeKEY(entry), HeKLEN(entry));
1176 = save_hek_flags(HeKEY(entry), HeKLEN(entry),
1177 hash, HeKFLAGS(entry));
1178 unshare_hek (HeKEY_hek(entry));
1179 HeKEY_hek(entry) = new_hek;
1182 HeHASH(entry) = hash;
1184 /*PerlIO_printf(PerlIO_stderr(), "%d ", HeKFLAGS(entry));*/
1185 HEK_REHASH_on(HeKEY_hek(entry));
1186 /*PerlIO_printf(PerlIO_stderr(), "%d\n", HeKFLAGS(entry));*/
1192 HeNEXT(entry) = *bep;
1193 *bep = entry;
1195 entry = next;
1212 register HE *entry;
1264 for (oentry = aep, entry = *aep; entry; entry = *oentry) {
1265 if ((j = (HeHASH(entry) & newsize)) != i) {
1267 *oentry = HeNEXT(entry);
1268 if (!(HeNEXT(entry) = aep[j]))
1270 aep[j] = entry;
1274 oentry = &HeNEXT(entry);
1367 HE *entry;
1377 while ((entry = hv_iternext_flags(ohv, 0))) {
1378 hv_store_flags(hv, HeKEY(entry), HeKLEN(entry),
1379 newSVsv(HeVAL(entry)), HeHASH(entry),
1380 HeKFLAGS(entry));
1390 Perl_hv_free_ent(pTHX_ HV *hv, register HE *entry)
1394 if (!entry)
1396 val = HeVAL(entry);
1400 if (HeKLEN(entry) == HEf_SVKEY) {
1401 SvREFCNT_dec(HeKEY_sv(entry));
1402 Safefree(HeKEY_hek(entry));
1405 unshare_hek(HeKEY_hek(entry));
1407 Safefree(HeKEY_hek(entry));
1408 del_HE(entry);
1412 Perl_hv_delayfree_ent(pTHX_ HV *hv, register HE *entry)
1414 if (!entry)
1416 if (isGV(HeVAL(entry)) && GvCVu(HeVAL(entry)) && HvNAME(hv))
1418 sv_2mortal(HeVAL(entry)); /* free between statements */
1419 if (HeKLEN(entry) == HEf_SVKEY) {
1420 sv_2mortal(HeKEY_sv(entry));
1421 Safefree(HeKEY_hek(entry));
1424 unshare_hek(HeKEY_hek(entry));
1426 Safefree(HeKEY_hek(entry));
1427 del_HE(entry);
1450 HE* entry;
1452 entry = ((HE**)xhv->xhv_array)[i];
1453 for (; entry; entry = HeNEXT(entry)) {
1455 if (HeVAL(entry) != &PL_sv_placeholder) {
1456 if (HeVAL(entry) && SvREADONLY(HeVAL(entry))) {
1457 SV* keysv = hv_iterkeysv(entry);
1462 SvREFCNT_dec(HeVAL(entry));
1463 HeVAL(entry) = &PL_sv_placeholder;
1513 HE *entry = *oentry;
1515 if (!entry)
1518 for (; entry; entry = *oentry) {
1519 if (HeVAL(entry) == &PL_sv_placeholder) {
1520 *oentry = HeNEXT(entry);
1526 hv_free_ent(hv, entry);
1537 oentry = &HeNEXT(entry);
1551 register HE *entry;
1570 entry = array[0];
1572 if (entry) {
1573 oentry = entry;
1574 entry = HeNEXT(entry);
1577 if (!entry) {
1580 entry = array[riter];
1637 HE *entry;
1642 entry = xhv->xhv_eiter; /* HvEITER(hv) */
1643 if (entry && HvLAZYDEL(hv)) { /* was deleted earlier? */
1645 hv_free_ent(hv, entry);
1657 You may call C<hv_delete> or C<hv_delete_ent> on the hash entry that the
1659 iterator. Note that in this case the current entry is deleted from the hash
1661 to free the entry on the next call to C<hv_iternext>, so you must not discard
1662 your iterator immediately else the entry will leak - call C<hv_iternext> to
1693 register HE *entry;
1700 oldentry = entry = xhv->xhv_eiter; /* HvEITER(hv) */
1704 if (entry) {
1705 sv_setsv(key, HeSVKEY_force(entry));
1706 SvREFCNT_dec(HeSVKEY(entry)); /* get rid of previous key */
1713 xhv->xhv_eiter = entry = new_HE(); /* HvEITER(hv) = new_HE() */
1714 Zero(entry, 1, HE);
1717 HeKEY_hek(entry) = hek;
1718 HeKLEN(entry) = HEf_SVKEY;
1723 HeSVKEY_set(entry, SvREFCNT_inc(key));
1724 return entry; /* beware, hent_val is not set */
1726 if (HeVAL(entry))
1727 SvREFCNT_dec(HeVAL(entry));
1728 Safefree(HeKEY_hek(entry));
1729 del_HE(entry);
1734 if (!entry && SvRMAGICAL((SV*)hv) && mg_find((SV*)hv, PERL_MAGIC_env))
1742 /* At start of hash, entry is NULL. */
1743 if (entry)
1745 entry = HeNEXT(entry);
1751 while (entry && HeVAL(entry) == &PL_sv_placeholder) {
1752 entry = HeNEXT(entry);
1756 while (!entry) {
1765 /* entry = (HvARRAY(hv))[HvRITER(hv)]; */
1766 entry = ((HE**)xhv->xhv_array)[xhv->xhv_riter];
1769 /* If we have an entry, but it's a placeholder, don't count it.
1771 while (entry && HeVAL(entry) == &PL_sv_placeholder)
1772 entry = HeNEXT(entry);
1784 /*if (HvREHASH(hv) && entry && !HeKREHASH(entry))
1785 PerlIO_printf(PerlIO_stderr(), "Awooga %p %p\n", hv, entry);*/
1787 xhv->xhv_eiter = entry; /* HvEITER(hv) = entry */
1788 return entry;
1801 Perl_hv_iterkey(pTHX_ register HE *entry, I32 *retlen)
1803 if (HeKLEN(entry) == HEf_SVKEY) {
1805 char *p = SvPV(HeKEY_sv(entry), len);
1810 *retlen = HeKLEN(entry);
1811 return HeKEY(entry);
1827 Perl_hv_iterkeysv(pTHX_ register HE *entry)
1829 if (HeKLEN(entry) != HEf_SVKEY) {
1830 HEK *hek = HeKEY_hek(entry);
1861 return sv_mortalcopy(HeKEY_sv(entry));
1874 Perl_hv_iterval(pTHX_ HV *hv, register HE *entry)
1879 if (HeKLEN(entry) == HEf_SVKEY)
1880 mg_copy((SV*)hv, sv, (char*)HeKEY_sv(entry), HEf_SVKEY);
1881 else mg_copy((SV*)hv, sv, HeKEY(entry), HeKLEN(entry));
1885 return HeVAL(entry);
1955 register HE *entry;
1988 for (entry = *oentry; entry; i=0, oentry = &HeNEXT(entry), entry = *oentry) {
1989 if (HeKEY_hek(entry) != hek)
1996 for (entry = *oentry; entry; i=0, oentry = &HeNEXT(entry), entry = *oentry) {
1997 if (HeHASH(entry) != hash) /* strings can't be equal */
1999 if (HeKLEN(entry) != len)
2001 if (HeKEY(entry) != str && memNE(HeKEY(entry),str,len)) /* is this it? */
2003 if (HeKFLAGS(entry) != flags_masked)
2011 if (--HeVAL(entry) == Nullsv) {
2012 *oentry = HeNEXT(entry);
2015 Safefree(HeKEY_hek(entry));
2016 del_HE(entry);
2066 register HE *entry;
2085 for (entry = *oentry; entry; i=0, entry = HeNEXT(entry)) {
2086 if (HeHASH(entry) != hash) /* strings can't be equal */
2088 if (HeKLEN(entry) != len)
2090 if (HeKEY(entry) != str && memNE(HeKEY(entry),str,len)) /* is this it? */
2092 if (HeKFLAGS(entry) != flags_masked)
2098 entry = new_HE();
2099 HeKEY_hek(entry) = save_hek_flags(str, len, hash, flags_masked);
2100 HeVAL(entry) = Nullsv;
2101 HeNEXT(entry) = *oentry;
2102 *oentry = entry;
2104 if (i) { /* initial entry? */
2111 ++HeVAL(entry); /* use value slot as REFCNT */
2117 return HeKEY_hek(entry);