3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * '...for the Entwives desired order, and plenty, and peace (by which they
13 * meant that things should remain where they had set them).' --Treebeard
15 * [p.476 of _The Lord of the Rings_, III/iv: "Treebeard"]
19 =head1 Array Manipulation Functions
27 Perl_av_reify(pTHX_ AV *av)
31 PERL_ARGS_ASSERT_AV_REIFY;
32 assert(SvTYPE(av) == SVt_PVAV);
37 if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
38 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
41 while (key > AvFILLp(av) + 1)
42 AvARRAY(av)[--key] = NULL;
44 SV * const sv = AvARRAY(av)[--key];
45 if (sv != &PL_sv_undef)
46 SvREFCNT_inc_simple_void(sv);
48 key = AvARRAY(av) - AvALLOC(av);
50 AvALLOC(av)[--key] = NULL;
58 Pre-extend an array. The C<key> is the index to which the array should be
65 Perl_av_extend(pTHX_ AV *av, SSize_t key)
69 PERL_ARGS_ASSERT_AV_EXTEND;
70 assert(SvTYPE(av) == SVt_PVAV);
72 mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied);
74 SV *arg1 = sv_newmortal();
75 sv_setiv(arg1, (IV)(key + 1));
76 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(EXTEND), G_DISCARD, 1,
80 av_extend_guts(av,key,&AvMAX(av),&AvALLOC(av),&AvARRAY(av));
83 /* The guts of av_extend. *Not* for general use! */
85 Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp,
88 PERL_ARGS_ASSERT_AV_EXTEND_GUTS;
90 if (key < -1) /* -1 is legal */
92 "panic: av_extend_guts() negative count (%" IVdf ")", (IV)key);
99 if (av && *allocp != *arrayp) {
100 ary = *allocp + AvFILLp(av) + 1;
101 tmp = *arrayp - *allocp;
102 Move(*arrayp, *allocp, AvFILLp(av)+1, SV*);
109 if (key > *maxp - 10) {
110 newmax = key + *maxp;
117 #ifdef Perl_safesysmalloc_size
118 /* Whilst it would be quite possible to move this logic around
119 (as I did in the SV code), so as to set AvMAX(av) early,
120 based on calling Perl_safesysmalloc_size() immediately after
121 allocation, I'm not convinced that it is a great idea here.
122 In an array we have to loop round setting everything to
123 NULL, which means writing to memory, potentially lots
124 of it, whereas for the SV buffer case we don't touch the
125 "bonus" memory. So there there is no cost in telling the
126 world about it, whereas here we have to do work before we can
127 tell the world about it, and that work involves writing to
128 memory that might never be read. So, I feel, better to keep
129 the current lazy system of only writing to it if our caller
130 has a need for more space. NWC */
131 newmax = Perl_safesysmalloc_size((void*)*allocp) /
132 sizeof(const SV *) - 1;
137 /* overflow-safe version of newmax = key + *maxp/5 */
139 newmax = (key > SSize_t_MAX - newmax)
140 ? SSize_t_MAX : key + newmax;
143 /* it should really be newmax+1 here, but if newmax
144 * happens to equal SSize_t_MAX, then newmax+1 is
145 * undefined. This means technically we croak one
146 * index lower than we should in theory; in practice
147 * its unlikely the system has SSize_t_MAX/sizeof(SV*)
149 MEM_WRAP_CHECK_s(newmax, SV*, "Out of memory during array extend");
151 #ifdef STRESS_REALLOC
153 SV ** const old_alloc = *allocp;
154 Newx(*allocp, newmax+1, SV*);
155 Copy(old_alloc, *allocp, *maxp + 1, SV*);
159 Renew(*allocp,newmax+1, SV*);
161 #ifdef Perl_safesysmalloc_size
164 ary = *allocp + *maxp + 1;
165 tmp = newmax - *maxp;
166 if (av == PL_curstack) { /* Oops, grew stack (via av_store()?) */
167 PL_stack_sp = *allocp + (PL_stack_sp - PL_stack_base);
168 PL_stack_base = *allocp;
169 PL_stack_max = PL_stack_base + newmax;
173 newmax = key < 3 ? 3 : key;
175 /* see comment above about newmax+1*/
176 MEM_WRAP_CHECK_s(newmax, SV*, "Out of memory during array extend");
178 Newx(*allocp, newmax+1, SV*);
181 *allocp[0] = NULL; /* For the stacks */
183 if (av && AvREAL(av)) {
197 Returns the SV at the specified index in the array. The C<key> is the
198 index. If lval is true, you are guaranteed to get a real SV back (in case
199 it wasn't real before), which you can then modify. Check that the return
200 value is non-null before dereferencing it to a C<SV*>.
202 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
203 more information on how to use this function on tied arrays.
205 The rough perl equivalent is C<$myarray[$key]>.
211 S_adjust_index(pTHX_ AV *av, const MAGIC *mg, SSize_t *keyp)
213 bool adjust_index = 1;
215 /* Handle negative array indices 20020222 MJD */
216 SV * const ref = SvTIED_obj(MUTABLE_SV(av), mg);
218 if (SvROK(ref) && SvOBJECT(SvRV(ref))) {
219 SV * const * const negative_indices_glob =
220 hv_fetchs(SvSTASH(SvRV(ref)), NEGATIVE_INDICES_VAR, 0);
222 if (negative_indices_glob && isGV(*negative_indices_glob)
223 && SvTRUE(GvSV(*negative_indices_glob)))
229 *keyp += AvFILL(av) + 1;
237 Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
242 PERL_ARGS_ASSERT_AV_FETCH;
243 assert(SvTYPE(av) == SVt_PVAV);
245 if (UNLIKELY(SvRMAGICAL(av))) {
246 const MAGIC * const tied_magic
247 = mg_find((const SV *)av, PERL_MAGIC_tied);
248 if (tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata)) {
251 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
256 sv_upgrade(sv, SVt_PVLV);
257 mg_copy(MUTABLE_SV(av), sv, 0, key);
258 if (!tied_magic) /* for regdata, force leavesub to make copies */
261 LvTARG(sv) = sv; /* fake (SV**) */
262 return &(LvTARG(sv));
267 size = AvFILLp(av) + 1;
268 key += neg * size; /* handle negative index without using branch */
270 /* the cast from SSize_t to Size_t allows both (key < 0) and (key >= size)
271 * to be tested as a single condition */
272 if ((Size_t)key >= (Size_t)size) {
278 if (!AvARRAY(av)[key]) {
280 return lval ? av_store(av,key,newSV(0)) : NULL;
283 return &AvARRAY(av)[key];
289 Stores an SV in an array. The array index is specified as C<key>. The
290 return value will be C<NULL> if the operation failed or if the value did not
291 need to be actually stored within the array (as in the case of tied
292 arrays). Otherwise, it can be dereferenced
293 to get the C<SV*> that was stored
296 Note that the caller is responsible for suitably incrementing the reference
297 count of C<val> before the call, and decrementing it if the function
300 Approximate Perl equivalent: C<splice(@myarray, $key, 1, $val)>.
302 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
303 more information on how to use this function on tied arrays.
309 Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
313 PERL_ARGS_ASSERT_AV_STORE;
314 assert(SvTYPE(av) == SVt_PVAV);
316 /* S_regclass relies on being able to pass in a NULL sv
317 (unicode_alternate may be NULL).
320 if (SvRMAGICAL(av)) {
321 const MAGIC * const tied_magic = mg_find((const SV *)av, PERL_MAGIC_tied);
324 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
328 mg_copy(MUTABLE_SV(av), val, 0, key);
336 key += AvFILL(av) + 1;
341 if (SvREADONLY(av) && key >= AvFILL(av))
342 Perl_croak_no_modify();
344 if (!AvREAL(av) && AvREIFY(av))
349 if (AvFILLp(av) < key) {
351 if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
352 PL_stack_sp = PL_stack_base + key; /* XPUSH in disguise */
354 ary[++AvFILLp(av)] = NULL;
355 } while (AvFILLp(av) < key);
360 SvREFCNT_dec(ary[key]);
362 if (SvSMAGICAL(av)) {
363 const MAGIC *mg = SvMAGIC(av);
365 for (; mg; mg = mg->mg_moremagic) {
366 if (!isUPPER(mg->mg_type)) continue;
368 sv_magic(val, MUTABLE_SV(av), toLOWER(mg->mg_type), 0, key);
370 if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa) {
371 PL_delaymagic |= DM_ARRAY_ISA;
376 mg_set(MUTABLE_SV(av));
384 Creates a new AV and populates it with a list of SVs. The SVs are copied
385 into the array, so they may be freed after the call to C<av_make>. The new AV
386 will have a reference count of 1.
388 Perl equivalent: C<my @new_array = ($scalar1, $scalar2, $scalar3...);>
394 Perl_av_make(pTHX_ SSize_t size, SV **strp)
396 AV * const av = MUTABLE_AV(newSV_type(SVt_PVAV));
397 /* sv_upgrade does AvREAL_only() */
398 PERL_ARGS_ASSERT_AV_MAKE;
399 assert(SvTYPE(av) == SVt_PVAV);
401 if (size) { /* "defined" was returning undef for size==0 anyway. */
409 AvMAX(av) = size - 1;
411 /* avoid av being leaked if croak when calling magic below */
413 PL_tmps_stack[++PL_tmps_ix] = (SV*)av;
414 orig_ix = PL_tmps_ix;
416 for (i = 0; i < size; i++) {
419 /* Don't let sv_setsv swipe, since our source array might
420 have multiple references to the same temp scalar (e.g.
421 from a list slice) */
423 SvGETMAGIC(*strp); /* before newSV, in case it dies */
426 sv_setsv_flags(ary[i], *strp,
427 SV_DO_COW_SVSETSV|SV_NOSTEAL);
430 /* disarm av's leak guard */
431 if (LIKELY(PL_tmps_ix == orig_ix))
434 PL_tmps_stack[orig_ix] = &PL_sv_undef;
442 Frees the all the elements of an array, leaving it empty.
443 The XS equivalent of C<@array = ()>. See also L</av_undef>.
445 Note that it is possible that the actions of a destructor called directly
446 or indirectly by freeing an element of the array could cause the reference
447 count of the array itself to be reduced (e.g. by deleting an entry in the
448 symbol table). So it is a possibility that the AV could have been freed
449 (or even reallocated) on return from the call unless you hold a reference
456 Perl_av_clear(pTHX_ AV *av)
462 PERL_ARGS_ASSERT_AV_CLEAR;
463 assert(SvTYPE(av) == SVt_PVAV);
466 if (SvREFCNT(av) == 0) {
467 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
472 Perl_croak_no_modify();
474 /* Give any tie a chance to cleanup first */
475 if (SvRMAGICAL(av)) {
476 const MAGIC* const mg = SvMAGIC(av);
477 if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
478 PL_delaymagic |= DM_ARRAY_ISA;
480 mg_clear(MUTABLE_SV(av));
486 if ((real = cBOOL(AvREAL(av)))) {
487 SV** const ary = AvARRAY(av);
488 SSize_t index = AvFILLp(av) + 1;
490 /* avoid av being freed when calling destructors below */
492 PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
493 orig_ix = PL_tmps_ix;
496 SV * const sv = ary[--index];
497 /* undef the slot before freeing the value, because a
498 * destructor might try to modify this array */
503 extra = AvARRAY(av) - AvALLOC(av);
506 AvARRAY(av) = AvALLOC(av);
510 /* disarm av's premature free guard */
511 if (LIKELY(PL_tmps_ix == orig_ix))
514 PL_tmps_stack[orig_ix] = &PL_sv_undef;
522 Undefines the array. The XS equivalent of C<undef(@array)>.
524 As well as freeing all the elements of the array (like C<av_clear()>), this
525 also frees the memory used by the av to store its list of scalars.
527 See L</av_clear> for a note about the array possibly being invalid on
534 Perl_av_undef(pTHX_ AV *av)
537 SSize_t orig_ix = PL_tmps_ix; /* silence bogus warning about possible unitialized use */
539 PERL_ARGS_ASSERT_AV_UNDEF;
540 assert(SvTYPE(av) == SVt_PVAV);
542 /* Give any tie a chance to cleanup first */
543 if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
546 real = cBOOL(AvREAL(av));
548 SSize_t key = AvFILLp(av) + 1;
550 /* avoid av being freed when calling destructors below */
552 PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
553 orig_ix = PL_tmps_ix;
556 SvREFCNT_dec(AvARRAY(av)[--key]);
559 Safefree(AvALLOC(av));
562 AvMAX(av) = AvFILLp(av) = -1;
564 if(SvRMAGICAL(av)) mg_clear(MUTABLE_SV(av));
566 /* disarm av's premature free guard */
567 if (LIKELY(PL_tmps_ix == orig_ix))
570 PL_tmps_stack[orig_ix] = &PL_sv_undef;
577 =for apidoc av_create_and_push
579 Push an SV onto the end of the array, creating the array if necessary.
580 A small internal helper function to remove a commonly duplicated idiom.
586 Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val)
588 PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH;
598 Pushes an SV (transferring control of one reference count) onto the end of the
599 array. The array will grow automatically to accommodate the addition.
601 Perl equivalent: C<push @myarray, $val;>.
607 Perl_av_push(pTHX_ AV *av, SV *val)
611 PERL_ARGS_ASSERT_AV_PUSH;
612 assert(SvTYPE(av) == SVt_PVAV);
615 Perl_croak_no_modify();
617 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
618 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(PUSH), G_DISCARD, 1,
622 av_store(av,AvFILLp(av)+1,val);
628 Removes one SV from the end of the array, reducing its size by one and
629 returning the SV (transferring control of one reference count) to the
630 caller. Returns C<&PL_sv_undef> if the array is empty.
632 Perl equivalent: C<pop(@myarray);>
638 Perl_av_pop(pTHX_ AV *av)
643 PERL_ARGS_ASSERT_AV_POP;
644 assert(SvTYPE(av) == SVt_PVAV);
647 Perl_croak_no_modify();
648 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
649 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(POP), 0, 0);
651 retval = newSVsv(retval);
656 retval = AvARRAY(av)[AvFILLp(av)];
657 AvARRAY(av)[AvFILLp(av)--] = NULL;
659 mg_set(MUTABLE_SV(av));
660 return retval ? retval : &PL_sv_undef;
665 =for apidoc av_create_and_unshift_one
667 Unshifts an SV onto the beginning of the array, creating the array if
669 A small internal helper function to remove a commonly duplicated idiom.
675 Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val)
677 PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE;
682 return av_store(*avp, 0, val);
686 =for apidoc av_unshift
688 Unshift the given number of C<undef> values onto the beginning of the
689 array. The array will grow automatically to accommodate the addition.
691 Perl equivalent: S<C<unshift @myarray, ((undef) x $num);>>
697 Perl_av_unshift(pTHX_ AV *av, SSize_t num)
702 PERL_ARGS_ASSERT_AV_UNSHIFT;
703 assert(SvTYPE(av) == SVt_PVAV);
706 Perl_croak_no_modify();
708 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
709 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(UNSHIFT),
710 G_DISCARD | G_UNDEF_FILL, num);
716 if (!AvREAL(av) && AvREIFY(av))
718 i = AvARRAY(av) - AvALLOC(av);
726 AvARRAY(av) = AvARRAY(av) - i;
730 const SSize_t i = AvFILLp(av);
731 /* Create extra elements */
732 const SSize_t slide = i > 0 ? i : 0;
734 av_extend(av, i + num);
737 Move(ary, ary + num, i + 1, SV*);
741 /* Make extra elements into a buffer */
743 AvFILLp(av) -= slide;
744 AvARRAY(av) = AvARRAY(av) + slide;
751 Removes one SV from the start of the array, reducing its size by one and
752 returning the SV (transferring control of one reference count) to the
753 caller. Returns C<&PL_sv_undef> if the array is empty.
755 Perl equivalent: C<shift(@myarray);>
761 Perl_av_shift(pTHX_ AV *av)
766 PERL_ARGS_ASSERT_AV_SHIFT;
767 assert(SvTYPE(av) == SVt_PVAV);
770 Perl_croak_no_modify();
771 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
772 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(SHIFT), 0, 0);
774 retval = newSVsv(retval);
779 retval = *AvARRAY(av);
782 AvARRAY(av) = AvARRAY(av) + 1;
786 mg_set(MUTABLE_SV(av));
787 return retval ? retval : &PL_sv_undef;
791 =for apidoc av_top_index
793 Returns the highest index in the array. The number of elements in the
794 array is S<C<av_top_index(av) + 1>>. Returns -1 if the array is empty.
796 The Perl equivalent for this is C<$#myarray>.
798 (A slightly shorter form is C<av_tindex>.)
802 Same as L</av_top_index>. Note that, unlike what the name implies, it returns
803 the highest index in the array, so to get the size of the array you need to use
804 S<C<av_len(av) + 1>>. This is unlike L</sv_len>, which returns what you would
811 Perl_av_len(pTHX_ AV *av)
813 PERL_ARGS_ASSERT_AV_LEN;
815 return av_top_index(av);
821 Set the highest index in the array to the given number, equivalent to
822 Perl's S<C<$#array = $fill;>>.
824 The number of elements in the array will be S<C<fill + 1>> after
825 C<av_fill()> returns. If the array was previously shorter, then the
826 additional elements appended are set to NULL. If the array
827 was longer, then the excess elements are freed. S<C<av_fill(av, -1)>> is
828 the same as C<av_clear(av)>.
833 Perl_av_fill(pTHX_ AV *av, SSize_t fill)
837 PERL_ARGS_ASSERT_AV_FILL;
838 assert(SvTYPE(av) == SVt_PVAV);
842 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
843 SV *arg1 = sv_newmortal();
844 sv_setiv(arg1, (IV)(fill + 1));
845 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(STORESIZE), G_DISCARD,
849 if (fill <= AvMAX(av)) {
850 SSize_t key = AvFILLp(av);
851 SV** const ary = AvARRAY(av);
855 SvREFCNT_dec(ary[key]);
866 mg_set(MUTABLE_SV(av));
869 (void)av_store(av,fill,NULL);
873 =for apidoc av_delete
875 Deletes the element indexed by C<key> from the array, makes the element
876 mortal, and returns it. If C<flags> equals C<G_DISCARD>, the element is
877 freed and NULL is returned. NULL is also returned if C<key> is out of
880 Perl equivalent: S<C<splice(@myarray, $key, 1, undef)>> (with the
881 C<splice> in void context if C<G_DISCARD> is present).
886 Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
890 PERL_ARGS_ASSERT_AV_DELETE;
891 assert(SvTYPE(av) == SVt_PVAV);
894 Perl_croak_no_modify();
896 if (SvRMAGICAL(av)) {
897 const MAGIC * const tied_magic
898 = mg_find((const SV *)av, PERL_MAGIC_tied);
899 if ((tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata))) {
902 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
905 svp = av_fetch(av, key, TRUE);
909 if (mg_find(sv, PERL_MAGIC_tiedelem)) {
910 sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
919 key += AvFILL(av) + 1;
924 if (key > AvFILLp(av))
927 if (!AvREAL(av) && AvREIFY(av))
929 sv = AvARRAY(av)[key];
930 AvARRAY(av)[key] = NULL;
931 if (key == AvFILLp(av)) {
934 } while (--key >= 0 && !AvARRAY(av)[key]);
937 mg_set(MUTABLE_SV(av));
940 if (flags & G_DISCARD) {
951 =for apidoc av_exists
953 Returns true if the element indexed by C<key> has been initialized.
955 This relies on the fact that uninitialized array elements are set to
958 Perl equivalent: C<exists($myarray[$key])>.
963 Perl_av_exists(pTHX_ AV *av, SSize_t key)
965 PERL_ARGS_ASSERT_AV_EXISTS;
966 assert(SvTYPE(av) == SVt_PVAV);
968 if (SvRMAGICAL(av)) {
969 const MAGIC * const tied_magic
970 = mg_find((const SV *)av, PERL_MAGIC_tied);
971 const MAGIC * const regdata_magic
972 = mg_find((const SV *)av, PERL_MAGIC_regdata);
973 if (tied_magic || regdata_magic) {
975 /* Handle negative array indices 20020222 MJD */
977 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
981 if(key >= 0 && regdata_magic) {
982 if (key <= AvFILL(av))
988 SV * const sv = sv_newmortal();
989 mg_copy(MUTABLE_SV(av), sv, 0, key);
990 mg = mg_find(sv, PERL_MAGIC_tiedelem);
992 magic_existspack(sv, mg);
994 I32 retbool = SvTRUE_nomg_NN(sv);
995 return cBOOL(retbool);
1003 key += AvFILL(av) + 1;
1008 if (key <= AvFILLp(av) && AvARRAY(av)[key])
1010 if (SvSMAGICAL(AvARRAY(av)[key])
1011 && mg_find(AvARRAY(av)[key], PERL_MAGIC_nonelem))
1020 S_get_aux_mg(pTHX_ AV *av) {
1023 PERL_ARGS_ASSERT_GET_AUX_MG;
1024 assert(SvTYPE(av) == SVt_PVAV);
1026 mg = mg_find((const SV *)av, PERL_MAGIC_arylen_p);
1029 mg = sv_magicext(MUTABLE_SV(av), 0, PERL_MAGIC_arylen_p,
1030 &PL_vtbl_arylen_p, 0, 0);
1032 /* sv_magicext won't set this for us because we pass in a NULL obj */
1033 mg->mg_flags |= MGf_REFCOUNTED;
1039 Perl_av_arylen_p(pTHX_ AV *av) {
1040 MAGIC *const mg = get_aux_mg(av);
1042 PERL_ARGS_ASSERT_AV_ARYLEN_P;
1043 assert(SvTYPE(av) == SVt_PVAV);
1045 return &(mg->mg_obj);
1049 Perl_av_iter_p(pTHX_ AV *av) {
1050 MAGIC *const mg = get_aux_mg(av);
1052 PERL_ARGS_ASSERT_AV_ITER_P;
1053 assert(SvTYPE(av) == SVt_PVAV);
1055 if (sizeof(IV) == sizeof(SSize_t)) {
1056 return (IV *)&(mg->mg_len);
1060 mg->mg_len = IVSIZE;
1062 mg->mg_ptr = (char *) temp;
1064 return (IV *)mg->mg_ptr;
1069 Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) {
1070 SV * const sv = newSV(0);
1071 PERL_ARGS_ASSERT_AV_NONELEM;
1072 if (!av_store(av,ix,sv))
1073 return sv_2mortal(sv); /* has tie magic */
1074 sv_magic(sv, NULL, PERL_MAGIC_nonelem, NULL, 0);
1079 * ex: set ts=8 sts=4 sw=4 et: