X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/1393e20655efb4bcc2062605bfe887dd5e634bc1..959068107bde652a5c1522a702e72d0c7d4a2d44:/av.c

diff --git a/av.c b/av.c
index e715d10..5aac5b1 100644
--- a/av.c
+++ b/av.c
@@ -21,10 +21,10 @@ av_reify(AV *av)
     I32 key;
     SV* sv;
 
-    if (AvREAL(av))                           
-	return;          
+    if (AvREAL(av))
+	return;
 #ifdef DEBUGGING
-    if (SvRMAGICAL(av) && mg_find((SV*)av,'P')) 
+    if (SvRMAGICAL(av) && mg_find((SV*)av,'P'))
 	warn("av_reify called on tied array");
 #endif
     key = AvMAX(av) + 1;
@@ -53,12 +53,14 @@ av_extend(AV *av, I32 key)
 	dSP;
 	ENTER;
 	SAVETMPS;
-	PUSHMARK(sp);
-	EXTEND(sp,2);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
+	EXTEND(SP,2);
 	PUSHs(mg->mg_obj);
-	PUSHs(sv_2mortal(newSViv(key)));
+	PUSHs(sv_2mortal(newSViv(key+1)));
         PUTBACK;
 	perl_call_method("EXTEND", G_SCALAR|G_DISCARD);
+	POPSTACK;
 	FREETMPS;
 	LEAVE;
 	return;
@@ -90,9 +92,15 @@ av_extend(AV *av, I32 key)
 		U32 bytes;
 #endif
 
+#ifdef MYMALLOC
+		newmax = malloced_size((void*)AvALLOC(av))/sizeof(SV*) - 1;
+
+		if (key <= newmax) 
+		    goto resized;
+#endif 
 		newmax = key + AvMAX(av) / 5;
 	      resize:
-#ifdef STRANGE_MALLOC
+#if defined(STRANGE_MALLOC) || defined(MYMALLOC)
 		Renew(AvALLOC(av),newmax+1, SV*);
 #else
 		bytes = (newmax + 1) * sizeof(SV*);
@@ -112,6 +120,7 @@ av_extend(AV *av, I32 key)
 		    Safefree(AvALLOC(av));
 		AvALLOC(av) = ary;
 #endif
+	      resized:
 		ary = AvALLOC(av) + AvMAX(av) + 1;
 		tmp = newmax - AvMAX(av);
 		if (av == curstack) {	/* Oops, grew stack (via av_store()?) */
@@ -121,7 +130,7 @@ av_extend(AV *av, I32 key)
 		}
 	    }
 	    else {
-		newmax = key < 4 ? 4 : key;
+		newmax = key < 3 ? 3 : key;
 		New(2,AvALLOC(av), newmax+1, SV*);
 		ary = AvALLOC(av) + 1;
 		tmp = newmax;
@@ -157,8 +166,8 @@ av_fetch(register AV *av, I32 key, I32 lval)
 	    dTHR;
 	    sv = sv_newmortal();
 	    mg_copy((SV*)av, sv, 0, key);
-	    Sv = sv;
-	    return &Sv;
+	    av_fetch_sv = sv;
+	    return &av_fetch_sv;
 	}
     }
 
@@ -321,14 +330,20 @@ av_clear(register AV *av)
 	warn("Attempt to clear deleted array");
     }
 #endif
-    if (!av || AvMAX(av) < 0)
+    if (!av)
 	return;
     /*SUPPRESS 560*/
 
+    if (SvREADONLY(av))
+	croak(no_modify);
+
     /* Give any tie a chance to cleanup first */
     if (SvRMAGICAL(av))
 	mg_clear((SV*)av); 
 
+    if (AvMAX(av) < 0)
+	return;
+
     if (AvREAL(av)) {
 	ary = AvARRAY(av);
 	key = AvFILLp(av) + 1;
@@ -364,7 +379,6 @@ av_undef(register AV *av)
 	    SvREFCNT_dec(AvARRAY(av)[--key]);
     }
     Safefree(AvALLOC(av));
-    AvARRAY(av) = 0;
     AvALLOC(av) = 0;
     SvPVX(av) = 0;
     AvMAX(av) = AvFILLp(av) = -1;
@@ -385,12 +399,16 @@ av_push(register AV *av, SV *val)
 
     if (SvRMAGICAL(av) && (mg = mg_find((SV*)av,'P'))) {
 	dSP;
-	PUSHMARK(sp);
-	EXTEND(sp,2);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
+	EXTEND(SP,2);
 	PUSHs(mg->mg_obj);
 	PUSHs(val);
-        PUTBACK;
+	PUTBACK;
+	ENTER;
 	perl_call_method("PUSH", G_SCALAR|G_DISCARD);
+	LEAVE;
+	POPSTACK;
 	return;
     }
     av_store(av,AvFILLp(av)+1,val);
@@ -408,14 +426,18 @@ av_pop(register AV *av)
 	croak(no_modify);
     if (SvRMAGICAL(av) && (mg = mg_find((SV*)av,'P'))) {
 	dSP;    
-	PUSHMARK(sp);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
 	XPUSHs(mg->mg_obj);
-        PUTBACK;
+	PUTBACK;
+	ENTER;
 	if (perl_call_method("POP", G_SCALAR)) {
 	    retval = newSVsv(*stack_sp--);    
 	} else {    
 	    retval = &sv_undef;
 	}
+	LEAVE;
+	POPSTACK;
 	return retval;
     }
     retval = AvARRAY(av)[AvFILLp(av)];
@@ -429,7 +451,7 @@ void
 av_unshift(register AV *av, register I32 num)
 {
     register I32 i;
-    register SV **sstr,**dstr;
+    register SV **ary;
     MAGIC* mg;
 
     if (!av || num <= 0)
@@ -439,14 +461,18 @@ av_unshift(register AV *av, register I32 num)
 
     if (SvRMAGICAL(av) && (mg = mg_find((SV*)av,'P'))) {
 	dSP;
-	PUSHMARK(sp);
-	EXTEND(sp,1+num);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
+	EXTEND(SP,1+num);
 	PUSHs(mg->mg_obj);
 	while (num-- > 0) {
 	    PUSHs(&sv_undef);
 	}
 	PUTBACK;
+	ENTER;
 	perl_call_method("UNSHIFT", G_SCALAR|G_DISCARD);
+	LEAVE;
+	POPSTACK;
 	return;
     }
 
@@ -463,21 +489,14 @@ av_unshift(register AV *av, register I32 num)
 	SvPVX(av) = (char*)(AvARRAY(av) - i);
     }
     if (num) {
-	av_extend(av,AvFILLp(av)+num);
+	i = AvFILLp(av);
+	av_extend(av, i + num);
 	AvFILLp(av) += num;
-	dstr = AvARRAY(av) + AvFILLp(av);
-	sstr = dstr - num;
-#ifdef BUGGY_MSC5
- # pragma loop_opt(off)	/* don't loop-optimize the following code */
-#endif /* BUGGY_MSC5 */
-	for (i = AvFILLp(av) - num; i >= 0; --i) {
-	    *dstr-- = *sstr--;
-#ifdef BUGGY_MSC5
- # pragma loop_opt()	/* loop-optimization back to command-line setting */
-#endif /* BUGGY_MSC5 */
-	}
-	while (num)
-	    AvARRAY(av)[--num] = &sv_undef;
+	ary = AvARRAY(av);
+	Move(ary, ary + num, i + 1, SV*);
+	do {
+	    ary[--num] = &sv_undef;
+	} while (num);
     }
 }
 
@@ -493,14 +512,18 @@ av_shift(register AV *av)
 	croak(no_modify);
     if (SvRMAGICAL(av) && (mg = mg_find((SV*)av,'P'))) {
 	dSP;
-	PUSHMARK(sp);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
 	XPUSHs(mg->mg_obj);
-        PUTBACK;
+	PUTBACK;
+	ENTER;
 	if (perl_call_method("SHIFT", G_SCALAR)) {
 	    retval = newSVsv(*stack_sp--);            
 	} else {    
 	    retval = &sv_undef;
-	}
+	}     
+	LEAVE;
+	POPSTACK;
 	return retval;
     }
     retval = *AvARRAY(av);
@@ -532,12 +555,14 @@ av_fill(register AV *av, I32 fill)
 	dSP;            
 	ENTER;
 	SAVETMPS;
-	PUSHMARK(sp);
-	EXTEND(sp,2);
+	PUSHSTACKi(PERLSI_MAGIC);
+	PUSHMARK(SP);
+	EXTEND(SP,2);
 	PUSHs(mg->mg_obj);
-	PUSHs(sv_2mortal(newSViv(fill)));
+	PUSHs(sv_2mortal(newSViv(fill+1)));
 	PUTBACK;
 	perl_call_method("STORESIZE", G_SCALAR|G_DISCARD);
+	POPSTACK;
 	FREETMPS;
 	LEAVE;
 	return;
@@ -565,14 +590,25 @@ av_fill(register AV *av, I32 fill)
 	(void)av_store(av,fill,&sv_undef);
 }
 
-  
+
+/* 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
+avhv_index_sv(SV* sv)
+{
+    I32 index = SvIV(sv);
+    if (index < 1)
+	croak("Bad index while coercing array into hash");
+    return index;    
+}
+
 HV*
 avhv_keys(AV *av)
 {
-    SV **keysp;
-    HV *keys = Nullhv;
-
-    keysp = av_fetch(av, 0, FALSE);
+    SV **keysp = av_fetch(av, 0, FALSE);
     if (keysp) {
 	SV *sv = *keysp;
 	if (SvGMAGICAL(sv))
@@ -580,34 +616,11 @@ avhv_keys(AV *av)
 	if (SvROK(sv)) {
 	    sv = SvRV(sv);
 	    if (SvTYPE(sv) == SVt_PVHV)
-		keys = (HV*)sv;
+		return (HV*)sv;
 	}
     }
-    if (!keys)
-	croak("Can't coerce array into hash");
-    return keys;
-}
-
-SV**
-avhv_fetch(AV *av, char *key, U32 klen, I32 lval)
-{
-    SV **indsvp;
-    HV *keys = avhv_keys(av);
-    I32 ind;
-    
-    indsvp = hv_fetch(keys, key, klen, FALSE);
-    if (indsvp) {
-	ind = SvIV(*indsvp);
-	if (ind < 1)
-	    croak("Bad index while coercing array into hash");
-    } else {
-	if (!lval)
-	    return 0;
-	
-	ind = AvFILL(av) + 1;
-	hv_store(keys, key, klen, newSViv(ind), 0);
-    }
-    return av_fetch(av, ind, lval);
+    croak("Can't coerce array into hash");
+    return Nullhv;
 }
 
 SV**
@@ -616,59 +629,11 @@ avhv_fetch_ent(AV *av, SV *keysv, I32 lval, U32 hash)
     SV **indsvp;
     HV *keys = avhv_keys(av);
     HE *he;
-    I32 ind;
-    
-    he = hv_fetch_ent(keys, keysv, FALSE, hash);
-    if (he) {
-	ind = SvIV(HeVAL(he));
-	if (ind < 1)
-	    croak("Bad index while coercing array into hash");
-    } else {
-	if (!lval)
-	    return 0;
-	
-	ind = AvFILL(av) + 1;
-	hv_store_ent(keys, keysv, newSViv(ind), 0);
-    }
-    return av_fetch(av, ind, lval);
-}
-
-SV**
-avhv_store(AV *av, char *key, U32 klen, SV *val, U32 hash)
-{
-    SV **indsvp;
-    HV *keys = avhv_keys(av);
-    I32 ind;
-    
-    indsvp = hv_fetch(keys, key, klen, FALSE);
-    if (indsvp) {
-	ind = SvIV(*indsvp);
-	if (ind < 1)
-	    croak("Bad index while coercing array into hash");
-    } else {
-	ind = AvFILL(av) + 1;
-	hv_store(keys, key, klen, newSViv(ind), hash);
-    }
-    return av_store(av, ind, val);
-}
-
-SV**
-avhv_store_ent(AV *av, SV *keysv, SV *val, U32 hash)
-{
-    HV *keys = avhv_keys(av);
-    HE *he;
-    I32 ind;
     
     he = hv_fetch_ent(keys, keysv, FALSE, hash);
-    if (he) {
-	ind = SvIV(HeVAL(he));
-	if (ind < 1)
-	    croak("Bad index while coercing array into hash");
-    } else {
-	ind = AvFILL(av) + 1;
-	hv_store_ent(keys, keysv, newSViv(ind), hash);
-    }
-    return av_store(av, ind, val);
+    if (!he)
+        croak("No such array field");
+    return av_fetch(av, avhv_index_sv(HeVAL(he)), lval);
 }
 
 bool
@@ -678,76 +643,6 @@ avhv_exists_ent(AV *av, SV *keysv, U32 hash)
     return hv_exists_ent(keys, keysv, hash);
 }
 
-bool
-avhv_exists(AV *av, char *key, U32 klen)
-{
-    HV *keys = avhv_keys(av);
-    return hv_exists(keys, key, klen);
-}
-
-/* avhv_delete leaks. Caller can re-index and compress if so desired. */
-SV *
-avhv_delete(AV *av, char *key, U32 klen, I32 flags)
-{
-    HV *keys = avhv_keys(av);
-    SV *sv;
-    SV **svp;
-    I32 ind;
-    
-    sv = hv_delete(keys, key, klen, 0);
-    if (!sv)
-	return Nullsv;
-    ind = SvIV(sv);
-    if (ind < 1)
-	croak("Bad index while coercing array into hash");
-    svp = av_fetch(av, ind, FALSE);
-    if (!svp)
-	return Nullsv;
-    if (flags & G_DISCARD) {
-	sv = Nullsv;
-	SvREFCNT_dec(*svp);
-    } else {
-	sv = sv_2mortal(*svp);
-    }
-    *svp = &sv_undef;
-    return sv;
-}
-
-/* avhv_delete_ent leaks. Caller can re-index and compress if so desired. */
-SV *
-avhv_delete_ent(AV *av, SV *keysv, I32 flags, U32 hash)
-{
-    HV *keys = avhv_keys(av);
-    SV *sv;
-    SV **svp;
-    I32 ind;
-    
-    sv = hv_delete_ent(keys, keysv, 0, hash);
-    if (!sv)
-	return Nullsv;
-    ind = SvIV(sv);
-    if (ind < 1)
-	croak("Bad index while coercing array into hash");
-    svp = av_fetch(av, ind, FALSE);
-    if (!svp)
-	return Nullsv;
-    if (flags & G_DISCARD) {
-	sv = Nullsv;
-	SvREFCNT_dec(*svp);
-    } else {
-	sv = sv_2mortal(*svp);
-    }
-    *svp = &sv_undef;
-    return sv;
-}
-
-I32
-avhv_iterinit(AV *av)
-{
-    HV *keys = avhv_keys(av);
-    return hv_iterinit(keys);
-}
-
 HE *
 avhv_iternext(AV *av)
 {
@@ -758,32 +653,6 @@ avhv_iternext(AV *av)
 SV *
 avhv_iterval(AV *av, register HE *entry)
 {
-    HV *keys = avhv_keys(av);
-    SV *sv;
-    I32 ind;
-    
-    sv = hv_iterval(keys, entry);
-    ind = SvIV(sv);
-    if (ind < 1)
-	croak("Bad index while coercing array into hash");
-    return *av_fetch(av, ind, TRUE);
-}
-
-SV *
-avhv_iternextsv(AV *av, char **key, I32 *retlen)
-{
-    HV *keys = avhv_keys(av);
-    HE *he;
-    SV *sv;
-    I32 ind;
-    
-    he = hv_iternext(keys);
-    if (!he)
-        return Nullsv;
-    *key = hv_iterkey(he, retlen);
-    sv = hv_iterval(keys, he);
-    ind = SvIV(sv);
-    if (ind < 1)
-	croak("Bad index while coercing array into hash");
-    return *av_fetch(av, ind, TRUE);
+    SV *sv = hv_iterval(avhv_keys(av), entry);
+    return *av_fetch(av, avhv_index_sv(sv), TRUE);
 }