/* av.c
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
+ * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 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.
dVAR;
I32 key;
- assert(av);
+ PERL_ARGS_ASSERT_AV_REIFY;
+ assert(SvTYPE(av) == SVt_PVAV);
if (AvREAL(av))
return;
dVAR;
MAGIC *mg;
- assert(av);
+ PERL_ARGS_ASSERT_AV_EXTEND;
+ assert(SvTYPE(av) == SVt_PVAV);
mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied);
if (mg) {
PUSHMARK(SP);
EXTEND(SP,2);
PUSHs(SvTIED_obj((SV*)av, mg));
- PUSHs(sv_2mortal(newSViv(key+1)));
+ mPUSHi(key + 1);
PUTBACK;
call_method("EXTEND", G_SCALAR|G_DISCARD);
POPSTACK;
IV itmp;
#endif
-#ifdef MYMALLOC
- newmax = malloced_size((void*)AvALLOC(av))/sizeof(SV*) - 1;
+#ifdef Perl_safesysmalloc_size
+ /* Whilst it would be quite possible to move this logic around
+ (as I did in the SV code), so as to set AvMAX(av) early,
+ based on calling Perl_safesysmalloc_size() immediately after
+ allocation, I'm not convinced that it is a great idea here.
+ In an array we have to loop round setting everything to
+ &PL_sv_undef, which means writing to memory, potentially lots
+ of it, whereas for the SV buffer case we don't touch the
+ "bonus" memory. So there there is no cost in telling the
+ world about it, whereas here we have to do work before we can
+ tell the world about it, and that work involves writing to
+ memory that might never be read. So, I feel, better to keep
+ the current lazy system of only writing to it if our caller
+ has a need for more space. NWC */
+ newmax = Perl_safesysmalloc_size((void*)AvALLOC(av)) /
+ sizeof(SV*) - 1;
if (key <= newmax)
goto resized;
Safefree(AvALLOC(av));
AvALLOC(av) = ary;
#endif
-#ifdef MYMALLOC
+#ifdef Perl_safesysmalloc_size
resized:
#endif
ary = AvALLOC(av) + AvMAX(av) + 1;
{
dVAR;
- assert(av);
+ PERL_ARGS_ASSERT_AV_FETCH;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvRMAGICAL(av)) {
const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
dVAR;
SV** ary;
- assert(av);
+ PERL_ARGS_ASSERT_AV_STORE;
+ assert(SvTYPE(av) == SVt_PVAV);
/* S_regclass relies on being able to pass in a NULL sv
(unicode_alternate may be NULL).
SvREFCNT_dec(ary[key]);
ary[key] = val;
if (SvSMAGICAL(av)) {
+ const MAGIC* const mg = SvMAGIC(av);
if (val != &PL_sv_undef) {
- const MAGIC* const mg = SvMAGIC(av);
sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
}
- mg_set((SV*)av);
+ if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa)
+ PL_delaymagic |= DM_ARRAY;
+ else
+ mg_set((SV*)av);
}
return &ary[key];
}
/*
-=for apidoc newAV
-
-Creates a new AV. The reference count is set to 1.
-
-=cut
-*/
-
-AV *
-Perl_newAV(pTHX)
-{
- register AV * const av = (AV*)newSV_type(SVt_PVAV);
- /* sv_upgrade does AvREAL_only() */
- AvALLOC(av) = 0;
- AvARRAY(av) = NULL;
- AvMAX(av) = AvFILLp(av) = -1;
- return av;
-}
-
-/*
=for apidoc av_make
Creates a new AV and populates it with a list of SVs. The SVs are copied
{
register AV * const av = (AV*)newSV_type(SVt_PVAV);
/* sv_upgrade does AvREAL_only() */
+ PERL_ARGS_ASSERT_AV_MAKE;
+ assert(SvTYPE(av) == SVt_PVAV);
+
if (size) { /* "defined" was returning undef for size==0 anyway. */
register SV** ary;
register I32 i;
dVAR;
I32 extra;
- assert(av);
+ PERL_ARGS_ASSERT_AV_CLEAR;
+ assert(SvTYPE(av) == SVt_PVAV);
+
#ifdef DEBUGGING
if (SvREFCNT(av) == 0 && ckWARN_d(WARN_DEBUGGING)) {
Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
Perl_croak(aTHX_ PL_no_modify);
/* Give any tie a chance to cleanup first */
- if (SvRMAGICAL(av))
- mg_clear((SV*)av);
+ if (SvRMAGICAL(av)) {
+ const MAGIC* const mg = SvMAGIC(av);
+ if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
+ PL_delaymagic |= DM_ARRAY;
+ else
+ mg_clear((SV*)av);
+ }
if (AvMAX(av) < 0)
return;
void
Perl_av_undef(pTHX_ register AV *av)
{
- assert(av);
+ PERL_ARGS_ASSERT_AV_UNDEF;
+ assert(SvTYPE(av) == SVt_PVAV);
/* Give any tie a chance to cleanup first */
if (SvTIED_mg((SV*)av, PERL_MAGIC_tied))
- av_fill(av, -1); /* mg_clear() ? */
+ av_fill(av, -1);
if (AvREAL(av)) {
register I32 key = AvFILLp(av) + 1;
while (key)
SvREFCNT_dec(AvARRAY(av)[--key]);
}
+
Safefree(AvALLOC(av));
AvALLOC(av) = NULL;
AvARRAY(av) = NULL;
AvMAX(av) = AvFILLp(av) = -1;
+
+ if(SvRMAGICAL(av)) mg_clear((SV*)av);
}
/*
void
Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val)
{
+ PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH;
+
if (!*avp)
*avp = newAV();
av_push(*avp, val);
{
dVAR;
MAGIC *mg;
- assert(av);
+
+ PERL_ARGS_ASSERT_AV_PUSH;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvREADONLY(av))
Perl_croak(aTHX_ PL_no_modify);
SV *retval;
MAGIC* mg;
- assert(av);
+ PERL_ARGS_ASSERT_AV_POP;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvREADONLY(av))
Perl_croak(aTHX_ PL_no_modify);
SV **
Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val)
{
+ PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE;
+
if (!*avp)
*avp = newAV();
av_unshift(*avp, 1);
register I32 i;
MAGIC* mg;
- assert(av);
+ PERL_ARGS_ASSERT_AV_UNSHIFT;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvREADONLY(av))
Perl_croak(aTHX_ PL_no_modify);
/*
=for apidoc av_shift
-Shifts an SV off the beginning of the array.
+Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the
+array is empty.
=cut
*/
SV *retval;
MAGIC* mg;
- assert(av);
+ PERL_ARGS_ASSERT_AV_SHIFT;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvREADONLY(av))
Perl_croak(aTHX_ PL_no_modify);
I32
Perl_av_len(pTHX_ register const AV *av)
{
- assert(av);
+ PERL_ARGS_ASSERT_AV_LEN;
+ assert(SvTYPE(av) == SVt_PVAV);
+
return AvFILL(av);
}
dVAR;
MAGIC *mg;
- assert(av);
+ PERL_ARGS_ASSERT_AV_FILL;
+ assert(SvTYPE(av) == SVt_PVAV);
if (fill < 0)
fill = -1;
PUSHMARK(SP);
EXTEND(SP,2);
PUSHs(SvTIED_obj((SV*)av, mg));
- PUSHs(sv_2mortal(newSViv(fill+1)));
+ mPUSHi(fill + 1);
PUTBACK;
call_method("STORESIZE", G_SCALAR|G_DISCARD);
POPSTACK;
dVAR;
SV *sv;
- assert(av);
+ PERL_ARGS_ASSERT_AV_DELETE;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvREADONLY(av))
Perl_croak(aTHX_ PL_no_modify);
Perl_av_exists(pTHX_ AV *av, I32 key)
{
dVAR;
- assert(av);
+ PERL_ARGS_ASSERT_AV_EXISTS;
+ assert(SvTYPE(av) == SVt_PVAV);
if (SvRMAGICAL(av)) {
const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
return FALSE;
}
-SV **
-Perl_av_arylen_p(pTHX_ AV *av) {
+MAGIC *
+S_get_aux_mg(pTHX_ AV *av) {
dVAR;
MAGIC *mg;
- assert(av);
+ PERL_ARGS_ASSERT_GET_AUX_MG;
+ assert(SvTYPE(av) == SVt_PVAV);
mg = mg_find((SV*)av, PERL_MAGIC_arylen_p);
/* sv_magicext won't set this for us because we pass in a NULL obj */
mg->mg_flags |= MGf_REFCOUNTED;
}
+ return mg;
+}
+
+SV **
+Perl_av_arylen_p(pTHX_ AV *av) {
+ MAGIC *const mg = get_aux_mg(av);
+
+ PERL_ARGS_ASSERT_AV_ARYLEN_P;
+ assert(SvTYPE(av) == SVt_PVAV);
+
return &(mg->mg_obj);
}
+IV *
+Perl_av_iter_p(pTHX_ AV *av) {
+ MAGIC *const mg = get_aux_mg(av);
+
+ PERL_ARGS_ASSERT_AV_ITER_P;
+ assert(SvTYPE(av) == SVt_PVAV);
+
+#if IVSIZE == I32SIZE
+ return (IV *)&(mg->mg_len);
+#else
+ if (!mg->mg_ptr) {
+ IV *temp;
+ mg->mg_len = IVSIZE;
+ Newxz(temp, 1, IV);
+ mg->mg_ptr = (char *) temp;
+ }
+ return (IV *)mg->mg_ptr;
+#endif
+}
+
/*
* Local variables:
* c-indentation-style: bsd
https://perl5.git.perl.org / perl5.git / blobdiff