X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=av.c;h=12b2ee3e4171ce71cec0497874a77b5dd788cc4e;hb=0159f81bfe8e286f119bb9a00f0567234a23235b;hp=d0428925a702007dd2aea5f3d89591f2a8db2005;hpb=eb1102fcca2230364ceadea29bd8e87ee51b15fa;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/av.c b/av.c
index d042892..12b2ee3 100644
--- a/av.c
+++ b/av.c
@@ -1,6 +1,7 @@
 /*    av.c
  *
- *    Copyright (c) 1991-2002, Larry Wall
+ *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ *    2000, 2001, 2002, 2003, 2004, 2005 by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -24,19 +25,18 @@ void
 Perl_av_reify(pTHX_ AV *av)
 {
     I32 key;
-    SV* sv;
 
     if (AvREAL(av))
 	return;
 #ifdef DEBUGGING
     if (SvTIED_mg((SV*)av, PERL_MAGIC_tied) && ckWARN_d(WARN_DEBUGGING))
-	Perl_warner(aTHX_ WARN_DEBUGGING, "av_reify called on tied array");
+	Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
 #endif
     key = AvMAX(av) + 1;
     while (key > AvFILLp(av) + 1)
 	AvARRAY(av)[--key] = &PL_sv_undef;
     while (key) {
-	sv = AvARRAY(av)[--key];
+	SV * const sv = AvARRAY(av)[--key];
 	assert(sv);
 	if (sv != &PL_sv_undef)
 	    (void)SvREFCNT_inc(sv);
@@ -87,7 +87,7 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 	    tmp = AvARRAY(av) - AvALLOC(av);
 	    Move(AvARRAY(av), AvALLOC(av), AvFILLp(av)+1, SV*);
 	    AvMAX(av) += tmp;
-	    SvPVX(av) = (char*)AvALLOC(av);
+	    SvPV_set(av, (char*)AvALLOC(av));
 	    if (AvREAL(av)) {
 		while (tmp)
 		    ary[--tmp] = &PL_sv_undef;
@@ -99,13 +99,18 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 	    }
 	}
 	else {
+#ifdef PERL_MALLOC_WRAP
+	    static const char oom_array_extend[] =
+	      "Out of memory during array extend"; /* Duplicated in pp_hot.c */
+#endif
+
 	    if (AvALLOC(av)) {
 #if !defined(STRANGE_MALLOC) && !defined(MYMALLOC)
 		MEM_SIZE bytes;
 		IV itmp;
 #endif
 
-#if defined(MYMALLOC) && !defined(LEAKTEST)
+#ifdef MYMALLOC
 		newmax = malloced_size((void*)AvALLOC(av))/sizeof(SV*) - 1;
 
 		if (key <= newmax) 
@@ -113,13 +118,14 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 #endif 
 		newmax = key + AvMAX(av) / 5;
 	      resize:
+		MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
 #if defined(STRANGE_MALLOC) || defined(MYMALLOC)
 		Renew(AvALLOC(av),newmax+1, SV*);
 #else
 		bytes = (newmax + 1) * sizeof(SV*);
 #define MALLOC_OVERHEAD 16
 		itmp = MALLOC_OVERHEAD;
-		while (itmp - MALLOC_OVERHEAD < bytes)
+		while ((MEM_SIZE)(itmp - MALLOC_OVERHEAD) < bytes)
 		    itmp += itmp;
 		itmp -= MALLOC_OVERHEAD;
 		itmp /= sizeof(SV*);
@@ -134,7 +140,7 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 		    Safefree(AvALLOC(av));
 		AvALLOC(av) = ary;
 #endif
-#if defined(MYMALLOC) && !defined(LEAKTEST)
+#ifdef MYMALLOC
 	      resized:
 #endif
 		ary = AvALLOC(av) + AvMAX(av) + 1;
@@ -147,6 +153,7 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 	    }
 	    else {
 		newmax = key < 3 ? 3 : key;
+		MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
 		New(2,AvALLOC(av), newmax+1, SV*);
 		ary = AvALLOC(av) + 1;
 		tmp = newmax;
@@ -157,7 +164,7 @@ Perl_av_extend(pTHX_ AV *av, I32 key)
 		    ary[--tmp] = &PL_sv_undef;
 	    }
 	    
-	    SvPVX(av) = (char*)AvALLOC(av);
+	    SvPV_set(av, (char*)AvALLOC(av));
 	    AvMAX(av) = newmax;
 	}
     }
@@ -184,23 +191,44 @@ Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval)
     if (!av)
 	return 0;
 
+    if (SvRMAGICAL(av)) {
+        const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
+        if (tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata)) {
+            U32 adjust_index = 1;
+
+            if (tied_magic && key < 0) {
+                /* Handle negative array indices 20020222 MJD */
+                SV **negative_indices_glob = 
+                    hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
+                                                     tied_magic))), 
+                             NEGATIVE_INDICES_VAR, 16, 0);
+
+                if (negative_indices_glob
+                    && SvTRUE(GvSV(*negative_indices_glob)))
+                    adjust_index = 0;
+            }
+
+            if (key < 0 && adjust_index) {
+                key += AvFILL(av) + 1;
+                if (key < 0)
+                    return 0;
+            }
+
+            sv = sv_newmortal();
+	    sv_upgrade(sv, SVt_PVLV);
+	    mg_copy((SV*)av, sv, 0, key);
+	    LvTYPE(sv) = 't';
+	    LvTARG(sv) = sv; /* fake (SV**) */
+	    return &(LvTARG(sv));
+        }
+    }
+
     if (key < 0) {
 	key += AvFILL(av) + 1;
 	if (key < 0)
 	    return 0;
     }
 
-    if (SvRMAGICAL(av)) {
-	if (mg_find((SV*)av, PERL_MAGIC_tied) ||
-		mg_find((SV*)av, PERL_MAGIC_regdata))
-	{
-	    sv = sv_newmortal();
-	    mg_copy((SV*)av, sv, 0, key);
-	    PL_av_fetch_sv = sv;
-	    return &PL_av_fetch_sv;
-	}
-    }
-
     if (key > AvFILLp(av)) {
 	if (!lval)
 	    return 0;
@@ -251,6 +279,33 @@ Perl_av_store(pTHX_ register AV *av, I32 key, SV *val)
     if (!val)
 	val = &PL_sv_undef;
 
+    if (SvRMAGICAL(av)) {
+        const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
+        if (tied_magic) {
+            /* Handle negative array indices 20020222 MJD */
+            if (key < 0) {
+                unsigned adjust_index = 1;
+                SV **negative_indices_glob = 
+                    hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
+                                                     tied_magic))), 
+                             NEGATIVE_INDICES_VAR, 16, 0);
+                if (negative_indices_glob
+                    && SvTRUE(GvSV(*negative_indices_glob)))
+                    adjust_index = 0;
+                if (adjust_index) {
+                    key += AvFILL(av) + 1;
+                    if (key < 0)
+                        return 0;
+                }
+            }
+	    if (val != &PL_sv_undef) {
+		mg_copy((SV*)av, val, 0, key);
+	    }
+	    return 0;
+        }
+    }
+
+
     if (key < 0) {
 	key += AvFILL(av) + 1;
 	if (key < 0)
@@ -260,15 +315,6 @@ Perl_av_store(pTHX_ register AV *av, I32 key, SV *val)
     if (SvREADONLY(av) && key >= AvFILL(av))
 	Perl_croak(aTHX_ PL_no_modify);
 
-    if (SvRMAGICAL(av)) {
-	if (mg_find((SV*)av, PERL_MAGIC_tied)) {
-	    if (val != &PL_sv_undef) {
-		mg_copy((SV*)av, val, 0, key);
-	    }
-	    return 0;
-	}
-    }
-
     if (!AvREAL(av) && AvREIFY(av))
 	av_reify(av);
     if (key > AvMAX(av))
@@ -314,7 +360,7 @@ Perl_newAV(pTHX)
     sv_upgrade((SV *)av, SVt_PVAV);
     AvREAL_on(av);
     AvALLOC(av) = 0;
-    SvPVX(av) = 0;
+    SvPV_set(av, (char*)0);
     AvMAX(av) = AvFILLp(av) = -1;
     return av;
 }
@@ -333,16 +379,16 @@ AV *
 Perl_av_make(pTHX_ register I32 size, register SV **strp)
 {
     register AV *av;
-    register I32 i;
-    register SV** ary;
 
     av = (AV*)NEWSV(8,0);
     sv_upgrade((SV *) av,SVt_PVAV);
-    AvFLAGS(av) = AVf_REAL;
+    AvREAL_only(av);
     if (size) {		/* `defined' was returning undef for size==0 anyway. */
+        register SV** ary;
+        register I32 i;
 	New(4,ary,size,SV*);
 	AvALLOC(av) = ary;
-	SvPVX(av) = (char*)ary;
+	SvPV_set(av, (char*)ary);
 	AvFILLp(av) = size - 1;
 	AvMAX(av) = size - 1;
 	for (i = 0; i < size; i++) {
@@ -366,8 +412,8 @@ Perl_av_fake(pTHX_ register I32 size, register SV **strp)
     New(4,ary,size+1,SV*);
     AvALLOC(av) = ary;
     Copy(strp,ary,size,SV*);
-    AvFLAGS(av) = AVf_REIFY;
-    SvPVX(av) = (char*)ary;
+    AvREIFY_only(av);
+    SvPV_set(av, (char*)ary);
     AvFILLp(av) = size - 1;
     AvMAX(av) = size - 1;
     while (size--) {
@@ -391,11 +437,10 @@ void
 Perl_av_clear(pTHX_ register AV *av)
 {
     register I32 key;
-    SV** ary;
 
 #ifdef DEBUGGING
     if (SvREFCNT(av) == 0 && ckWARN_d(WARN_DEBUGGING)) {
-	Perl_warner(aTHX_ WARN_DEBUGGING, "Attempt to clear deleted array");
+	Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
     }
 #endif
     if (!av)
@@ -413,16 +458,19 @@ Perl_av_clear(pTHX_ register AV *av)
 	return;
 
     if (AvREAL(av)) {
-	ary = AvARRAY(av);
+        SV** ary = AvARRAY(av);
 	key = AvFILLp(av) + 1;
 	while (key) {
-	    SvREFCNT_dec(ary[--key]);
+	    SV * sv = ary[--key];
+	    /* undef the slot before freeing the value, because a
+	     * destructor might try to modify this arrray */
 	    ary[key] = &PL_sv_undef;
+	    SvREFCNT_dec(sv);
 	}
     }
     if ((key = AvARRAY(av) - AvALLOC(av))) {
 	AvMAX(av) += key;
-	SvPVX(av) = (char*)AvALLOC(av);
+	SvPV_set(av, (char*)AvALLOC(av));
     }
     AvFILLp(av) = -1;
 
@@ -439,8 +487,6 @@ Undefines the array.  Frees the memory used by the array itself.
 void
 Perl_av_undef(pTHX_ register AV *av)
 {
-    register I32 key;
-
     if (!av)
 	return;
     /*SUPPRESS 560*/
@@ -450,13 +496,13 @@ Perl_av_undef(pTHX_ register AV *av)
 	av_fill(av, -1);   /* mg_clear() ? */
 
     if (AvREAL(av)) {
-	key = AvFILLp(av) + 1;
+	register I32 key = AvFILLp(av) + 1;
 	while (key)
 	    SvREFCNT_dec(AvARRAY(av)[--key]);
     }
     Safefree(AvALLOC(av));
     AvALLOC(av) = 0;
-    SvPVX(av) = 0;
+    SvPV_set(av, (char*)0);
     AvMAX(av) = AvFILLp(av) = -1;
     if (AvARYLEN(av)) {
 	SvREFCNT_dec(AvARYLEN(av));
@@ -476,6 +522,7 @@ to accommodate the addition.
 void
 Perl_av_push(pTHX_ register AV *av, SV *val)
 {             
+    dVAR;
     MAGIC *mg;
     if (!av)
 	return;
@@ -511,11 +558,12 @@ is empty.
 SV *
 Perl_av_pop(pTHX_ register AV *av)
 {
+    dVAR;
     SV *retval;
     MAGIC* mg;
 
-    if (!av || AvFILL(av) < 0)
-	return &PL_sv_undef;
+    if (!av)
+      return &PL_sv_undef;
     if (SvREADONLY(av))
 	Perl_croak(aTHX_ PL_no_modify);
     if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
@@ -534,6 +582,8 @@ Perl_av_pop(pTHX_ register AV *av)
 	POPSTACK;
 	return retval;
     }
+    if (AvFILL(av) < 0)
+	return &PL_sv_undef;
     retval = AvARRAY(av)[AvFILLp(av)];
     AvARRAY(av)[AvFILLp(av)--] = &PL_sv_undef;
     if (SvSMAGICAL(av))
@@ -554,12 +604,11 @@ must then use C<av_store> to assign values to these new elements.
 void
 Perl_av_unshift(pTHX_ register AV *av, register I32 num)
 {
+    dVAR;
     register I32 i;
-    register SV **ary;
     MAGIC* mg;
-    I32 slide;
 
-    if (!av || num <= 0)
+    if (!av)
 	return;
     if (SvREADONLY(av))
 	Perl_croak(aTHX_ PL_no_modify);
@@ -581,6 +630,8 @@ Perl_av_unshift(pTHX_ register AV *av, register I32 num)
 	return;
     }
 
+    if (num <= 0)
+      return;
     if (!AvREAL(av) && AvREIFY(av))
 	av_reify(av);
     i = AvARRAY(av) - AvALLOC(av);
@@ -591,9 +642,11 @@ Perl_av_unshift(pTHX_ register AV *av, register I32 num)
     
 	AvMAX(av) += i;
 	AvFILLp(av) += i;
-	SvPVX(av) = (char*)(AvARRAY(av) - i);
+	SvPV_set(av, (char*)(AvARRAY(av) - i));
     }
     if (num) {
+	register SV **ary;
+	I32 slide;
 	i = AvFILLp(av);
 	/* Create extra elements */
 	slide = i > 0 ? i : 0;
@@ -608,7 +661,7 @@ Perl_av_unshift(pTHX_ register AV *av, register I32 num)
 	/* Make extra elements into a buffer */
 	AvMAX(av) -= slide;
 	AvFILLp(av) -= slide;
-	SvPVX(av) = (char*)(AvARRAY(av) + slide);
+	SvPV_set(av, (char*)(AvARRAY(av) + slide));
     }
 }
 
@@ -623,10 +676,11 @@ Shifts an SV off the beginning of the array.
 SV *
 Perl_av_shift(pTHX_ register AV *av)
 {
+    dVAR;
     SV *retval;
     MAGIC* mg;
 
-    if (!av || AvFILL(av) < 0)
+    if (!av)
 	return &PL_sv_undef;
     if (SvREADONLY(av))
 	Perl_croak(aTHX_ PL_no_modify);
@@ -646,10 +700,12 @@ Perl_av_shift(pTHX_ register AV *av)
 	POPSTACK;
 	return retval;
     }
+    if (AvFILL(av) < 0)
+      return &PL_sv_undef;
     retval = *AvARRAY(av);
     if (AvREAL(av))
 	*AvARRAY(av) = &PL_sv_undef;
-    SvPVX(av) = (char*)(AvARRAY(av) + 1);
+    SvPV_set(av, (char*)(AvARRAY(av) + 1));
     AvMAX(av)--;
     AvFILLp(av)--;
     if (SvSMAGICAL(av))
@@ -667,7 +723,7 @@ empty.
 */
 
 I32
-Perl_av_len(pTHX_ register AV *av)
+Perl_av_len(pTHX_ const register AV *av)
 {
     return AvFILL(av);
 }
@@ -683,6 +739,7 @@ Perl's C<$#array = $fill;>.
 void
 Perl_av_fill(pTHX_ register AV *av, I32 fill)
 {
+    dVAR;
     MAGIC *mg;
     if (!av)
 	Perl_croak(aTHX_ "panic: null array");
@@ -731,7 +788,8 @@ Perl_av_fill(pTHX_ register AV *av, I32 fill)
 =for apidoc av_delete
 
 Deletes the element indexed by C<key> from the array.  Returns the
-deleted element. C<flags> is currently ignored.
+deleted element. If C<flags> equals C<G_DISCARD>, the element is freed
+and null is returned.
 
 =cut
 */
@@ -744,29 +802,53 @@ Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
 	return Nullsv;
     if (SvREADONLY(av))
 	Perl_croak(aTHX_ PL_no_modify);
+
+    if (SvRMAGICAL(av)) {
+        const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
+        if ((tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata))) {
+            /* Handle negative array indices 20020222 MJD */
+            SV **svp;
+            if (key < 0) {
+                unsigned adjust_index = 1;
+                if (tied_magic) {
+                    SV **negative_indices_glob = 
+                        hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
+                                                         tied_magic))), 
+                                 NEGATIVE_INDICES_VAR, 16, 0);
+                    if (negative_indices_glob
+                        && SvTRUE(GvSV(*negative_indices_glob)))
+                        adjust_index = 0;
+                }
+                if (adjust_index) {
+                    key += AvFILL(av) + 1;
+                    if (key < 0)
+                        return Nullsv;
+                }
+            }
+            svp = av_fetch(av, key, TRUE);
+            if (svp) {
+                sv = *svp;
+                mg_clear(sv);
+                if (mg_find(sv, PERL_MAGIC_tiedelem)) {
+                    sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
+                    return sv;
+                }
+                return Nullsv;     
+            }
+        }
+    }
+
     if (key < 0) {
 	key += AvFILL(av) + 1;
 	if (key < 0)
 	    return Nullsv;
     }
-    if (SvRMAGICAL(av)) {
-	SV **svp;
-	if ((mg_find((SV*)av, PERL_MAGIC_tied) ||
-		mg_find((SV*)av, PERL_MAGIC_regdata))
-	    && (svp = av_fetch(av, key, TRUE)))
-	{
-	    sv = *svp;
-	    mg_clear(sv);
-	    if (mg_find(sv, PERL_MAGIC_tiedelem)) {
-		sv_unmagic(sv, PERL_MAGIC_tiedelem);	/* No longer an element */
-		return sv;
-	    }
-	    return Nullsv;			/* element cannot be deleted */
-	}
-    }
+
     if (key > AvFILLp(av))
 	return Nullsv;
     else {
+	if (!AvREAL(av) && AvREIFY(av))
+	    av_reify(av);
 	sv = AvARRAY(av)[key];
 	if (key == AvFILLp(av)) {
 	    AvARRAY(av)[key] = &PL_sv_undef;
@@ -783,6 +865,8 @@ Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
 	SvREFCNT_dec(sv);
 	sv = Nullsv;
     }
+    else if (AvREAL(av))
+	sv = sv_2mortal(sv);
     return sv;
 }
 
@@ -801,26 +885,48 @@ Perl_av_exists(pTHX_ AV *av, I32 key)
 {
     if (!av)
 	return FALSE;
+
+
+    if (SvRMAGICAL(av)) {
+        const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
+        if (tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata)) {
+            SV *sv = sv_newmortal();
+            MAGIC *mg;
+            /* Handle negative array indices 20020222 MJD */
+            if (key < 0) {
+                unsigned adjust_index = 1;
+                if (tied_magic) {
+                    SV **negative_indices_glob = 
+                        hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
+                                                         tied_magic))), 
+                                 NEGATIVE_INDICES_VAR, 16, 0);
+                    if (negative_indices_glob
+                        && SvTRUE(GvSV(*negative_indices_glob)))
+                        adjust_index = 0;
+                }
+                if (adjust_index) {
+                    key += AvFILL(av) + 1;
+                    if (key < 0)
+                        return FALSE;
+                }
+            }
+
+            mg_copy((SV*)av, sv, 0, key);
+            mg = mg_find(sv, PERL_MAGIC_tiedelem);
+            if (mg) {
+                magic_existspack(sv, mg);
+                return (bool)SvTRUE(sv);
+            }
+
+        }
+    }
+
     if (key < 0) {
 	key += AvFILL(av) + 1;
 	if (key < 0)
 	    return FALSE;
     }
-    if (SvRMAGICAL(av)) {
-	if (mg_find((SV*)av, PERL_MAGIC_tied) ||
-		mg_find((SV*)av, PERL_MAGIC_regdata))
-	{
-	    SV *sv = sv_newmortal();
-	    MAGIC *mg;
 
-	    mg_copy((SV*)av, sv, 0, key);
-	    mg = mg_find(sv, PERL_MAGIC_tiedelem);
-	    if (mg) {
-		magic_existspack(sv, mg);
-		return SvTRUE(sv);
-	    }
-	}
-    }
     if (key <= AvFILLp(av) && AvARRAY(av)[key] != &PL_sv_undef
 	&& AvARRAY(av)[key])
     {
@@ -830,103 +936,12 @@ Perl_av_exists(pTHX_ AV *av, I32 key)
 	return FALSE;
 }
 
-/* AVHV: Support for treating arrays as if they were hashes.  The
- * first element of the array should be a hash reference that maps
- * hash keys to array indices.
- */
-
-STATIC I32
-S_avhv_index_sv(pTHX_ SV* sv)
-{
-    I32 index = SvIV(sv);
-    if (index < 1)
-	Perl_croak(aTHX_ "Bad index while coercing array into hash");
-    return index;    
-}
-
-STATIC I32
-S_avhv_index(pTHX_ AV *av, SV *keysv, U32 hash)
-{
-    HV *keys;
-    HE *he;
-    STRLEN n_a;
-
-    keys = avhv_keys(av);
-    he = hv_fetch_ent(keys, keysv, FALSE, hash);
-    if (!he)
-        Perl_croak(aTHX_ "No such pseudo-hash field \"%s\"", SvPV(keysv,n_a));
-    return avhv_index_sv(HeVAL(he));
-}
-
-HV*
-Perl_avhv_keys(pTHX_ AV *av)
-{
-    SV **keysp = av_fetch(av, 0, FALSE);
-    if (keysp) {
-	SV *sv = *keysp;
-	if (SvGMAGICAL(sv))
-	    mg_get(sv);
-	if (SvROK(sv)) {
-	    sv = SvRV(sv);
-	    if (SvTYPE(sv) == SVt_PVHV)
-		return (HV*)sv;
-	}
-    }
-    Perl_croak(aTHX_ "Can't coerce array into hash");
-    return Nullhv;
-}
-
-SV**
-Perl_avhv_store_ent(pTHX_ AV *av, SV *keysv, SV *val, U32 hash)
-{
-    return av_store(av, avhv_index(av, keysv, hash), val);
-}
-
-SV**
-Perl_avhv_fetch_ent(pTHX_ AV *av, SV *keysv, I32 lval, U32 hash)
-{
-    return av_fetch(av, avhv_index(av, keysv, hash), lval);
-}
-
-SV *
-Perl_avhv_delete_ent(pTHX_ AV *av, SV *keysv, I32 flags, U32 hash)
-{
-    HV *keys = avhv_keys(av);
-    HE *he;
-	
-    he = hv_fetch_ent(keys, keysv, FALSE, hash);
-    if (!he || !SvOK(HeVAL(he)))
-	return Nullsv;
-
-    return av_delete(av, avhv_index_sv(HeVAL(he)), flags);
-}
-
-/* Check for the existence of an element named by a given key.
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
  *
+ * ex: set ts=8 sts=4 sw=4 noet:
  */
-bool
-Perl_avhv_exists_ent(pTHX_ AV *av, SV *keysv, U32 hash)
-{
-    HV *keys = avhv_keys(av);
-    HE *he;
-	
-    he = hv_fetch_ent(keys, keysv, FALSE, hash);
-    if (!he || !SvOK(HeVAL(he)))
-	return FALSE;
-
-    return av_exists(av, avhv_index_sv(HeVAL(he)));
-}
-
-HE *
-Perl_avhv_iternext(pTHX_ AV *av)
-{
-    HV *keys = avhv_keys(av);
-    return hv_iternext(keys);
-}
-
-SV *
-Perl_avhv_iterval(pTHX_ AV *av, register HE *entry)
-{
-    SV *sv = hv_iterval(avhv_keys(av), entry);
-    return *av_fetch(av, avhv_index_sv(sv), TRUE);
-}