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 #ifdef PERL_MALLOC_WRAP /* Duplicated in pp_hot.c */
144 static const char oom_array_extend[] =
145 "Out of memory during array extend";
147 /* it should really be newmax+1 here, but if newmax
148 * happens to equal SSize_t_MAX, then newmax+1 is
149 * undefined. This means technically we croak one
150 * index lower than we should in theory; in practice
151 * its unlikely the system has SSize_t_MAX/sizeof(SV*)
153 MEM_WRAP_CHECK_1(newmax, SV*, oom_array_extend);
155 #ifdef STRESS_REALLOC
157 SV ** const old_alloc = *allocp;
158 Newx(*allocp, newmax+1, SV*);
159 Copy(old_alloc, *allocp, *maxp + 1, SV*);
163 Renew(*allocp,newmax+1, SV*);
165 #ifdef Perl_safesysmalloc_size
168 ary = *allocp + *maxp + 1;
169 tmp = newmax - *maxp;
170 if (av == PL_curstack) { /* Oops, grew stack (via av_store()?) */
171 PL_stack_sp = *allocp + (PL_stack_sp - PL_stack_base);
172 PL_stack_base = *allocp;
173 PL_stack_max = PL_stack_base + newmax;
177 newmax = key < 3 ? 3 : key;
179 #ifdef PERL_MALLOC_WRAP /* Duplicated in pp_hot.c */
180 static const char oom_array_extend[] =
181 "Out of memory during array extend";
183 /* see comment above about newmax+1*/
184 MEM_WRAP_CHECK_1(newmax, SV*, oom_array_extend);
186 Newx(*allocp, newmax+1, SV*);
189 *allocp[0] = NULL; /* For the stacks */
191 if (av && AvREAL(av)) {
205 Returns the SV at the specified index in the array. The C<key> is the
206 index. If lval is true, you are guaranteed to get a real SV back (in case
207 it wasn't real before), which you can then modify. Check that the return
208 value is non-null before dereferencing it to a C<SV*>.
210 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
211 more information on how to use this function on tied arrays.
213 The rough perl equivalent is C<$myarray[$key]>.
219 S_adjust_index(pTHX_ AV *av, const MAGIC *mg, SSize_t *keyp)
221 bool adjust_index = 1;
223 /* Handle negative array indices 20020222 MJD */
224 SV * const ref = SvTIED_obj(MUTABLE_SV(av), mg);
226 if (SvROK(ref) && SvOBJECT(SvRV(ref))) {
227 SV * const * const negative_indices_glob =
228 hv_fetchs(SvSTASH(SvRV(ref)), NEGATIVE_INDICES_VAR, 0);
230 if (negative_indices_glob && isGV(*negative_indices_glob)
231 && SvTRUE(GvSV(*negative_indices_glob)))
237 *keyp += AvFILL(av) + 1;
245 Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
250 PERL_ARGS_ASSERT_AV_FETCH;
251 assert(SvTYPE(av) == SVt_PVAV);
253 if (UNLIKELY(SvRMAGICAL(av))) {
254 const MAGIC * const tied_magic
255 = mg_find((const SV *)av, PERL_MAGIC_tied);
256 if (tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata)) {
259 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
264 sv_upgrade(sv, SVt_PVLV);
265 mg_copy(MUTABLE_SV(av), sv, 0, key);
266 if (!tied_magic) /* for regdata, force leavesub to make copies */
269 LvTARG(sv) = sv; /* fake (SV**) */
270 return &(LvTARG(sv));
275 size = AvFILLp(av) + 1;
276 key += neg * size; /* handle negative index without using branch */
278 /* the cast from SSize_t to Size_t allows both (key < 0) and (key >= size)
279 * to be tested as a single condition */
280 if ((Size_t)key >= (Size_t)size) {
286 if (!AvARRAY(av)[key]) {
288 return lval ? av_store(av,key,newSV(0)) : NULL;
291 return &AvARRAY(av)[key];
297 Stores an SV in an array. The array index is specified as C<key>. The
298 return value will be C<NULL> if the operation failed or if the value did not
299 need to be actually stored within the array (as in the case of tied
300 arrays). Otherwise, it can be dereferenced
301 to get the C<SV*> that was stored
304 Note that the caller is responsible for suitably incrementing the reference
305 count of C<val> before the call, and decrementing it if the function
308 Approximate Perl equivalent: C<splice(@myarray, $key, 1, $val)>.
310 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
311 more information on how to use this function on tied arrays.
317 Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
321 PERL_ARGS_ASSERT_AV_STORE;
322 assert(SvTYPE(av) == SVt_PVAV);
324 /* S_regclass relies on being able to pass in a NULL sv
325 (unicode_alternate may be NULL).
328 if (SvRMAGICAL(av)) {
329 const MAGIC * const tied_magic = mg_find((const SV *)av, PERL_MAGIC_tied);
332 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
336 mg_copy(MUTABLE_SV(av), val, 0, key);
344 key += AvFILL(av) + 1;
349 if (SvREADONLY(av) && key >= AvFILL(av))
350 Perl_croak_no_modify();
352 if (!AvREAL(av) && AvREIFY(av))
357 if (AvFILLp(av) < key) {
359 if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
360 PL_stack_sp = PL_stack_base + key; /* XPUSH in disguise */
362 ary[++AvFILLp(av)] = NULL;
363 } while (AvFILLp(av) < key);
368 SvREFCNT_dec(ary[key]);
370 if (SvSMAGICAL(av)) {
371 const MAGIC *mg = SvMAGIC(av);
373 for (; mg; mg = mg->mg_moremagic) {
374 if (!isUPPER(mg->mg_type)) continue;
376 sv_magic(val, MUTABLE_SV(av), toLOWER(mg->mg_type), 0, key);
378 if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa) {
379 PL_delaymagic |= DM_ARRAY_ISA;
384 mg_set(MUTABLE_SV(av));
392 Creates a new AV and populates it with a list of SVs. The SVs are copied
393 into the array, so they may be freed after the call to C<av_make>. The new AV
394 will have a reference count of 1.
396 Perl equivalent: C<my @new_array = ($scalar1, $scalar2, $scalar3...);>
402 Perl_av_make(pTHX_ SSize_t size, SV **strp)
404 AV * const av = MUTABLE_AV(newSV_type(SVt_PVAV));
405 /* sv_upgrade does AvREAL_only() */
406 PERL_ARGS_ASSERT_AV_MAKE;
407 assert(SvTYPE(av) == SVt_PVAV);
409 if (size) { /* "defined" was returning undef for size==0 anyway. */
417 AvMAX(av) = size - 1;
419 /* avoid av being leaked if croak when calling magic below */
421 PL_tmps_stack[++PL_tmps_ix] = (SV*)av;
422 orig_ix = PL_tmps_ix;
424 for (i = 0; i < size; i++) {
427 /* Don't let sv_setsv swipe, since our source array might
428 have multiple references to the same temp scalar (e.g.
429 from a list slice) */
431 SvGETMAGIC(*strp); /* before newSV, in case it dies */
434 sv_setsv_flags(ary[i], *strp,
435 SV_DO_COW_SVSETSV|SV_NOSTEAL);
438 /* disarm av's leak guard */
439 if (LIKELY(PL_tmps_ix == orig_ix))
442 PL_tmps_stack[orig_ix] = &PL_sv_undef;
450 Frees the all the elements of an array, leaving it empty.
451 The XS equivalent of C<@array = ()>. See also L</av_undef>.
453 Note that it is possible that the actions of a destructor called directly
454 or indirectly by freeing an element of the array could cause the reference
455 count of the array itself to be reduced (e.g. by deleting an entry in the
456 symbol table). So it is a possibility that the AV could have been freed
457 (or even reallocated) on return from the call unless you hold a reference
464 Perl_av_clear(pTHX_ AV *av)
470 PERL_ARGS_ASSERT_AV_CLEAR;
471 assert(SvTYPE(av) == SVt_PVAV);
474 if (SvREFCNT(av) == 0) {
475 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
480 Perl_croak_no_modify();
482 /* Give any tie a chance to cleanup first */
483 if (SvRMAGICAL(av)) {
484 const MAGIC* const mg = SvMAGIC(av);
485 if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
486 PL_delaymagic |= DM_ARRAY_ISA;
488 mg_clear(MUTABLE_SV(av));
494 if ((real = cBOOL(AvREAL(av)))) {
495 SV** const ary = AvARRAY(av);
496 SSize_t index = AvFILLp(av) + 1;
498 /* avoid av being freed when calling destructors below */
500 PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
501 orig_ix = PL_tmps_ix;
504 SV * const sv = ary[--index];
505 /* undef the slot before freeing the value, because a
506 * destructor might try to modify this array */
511 extra = AvARRAY(av) - AvALLOC(av);
514 AvARRAY(av) = AvALLOC(av);
518 /* disarm av's premature free guard */
519 if (LIKELY(PL_tmps_ix == orig_ix))
522 PL_tmps_stack[orig_ix] = &PL_sv_undef;
530 Undefines the array. The XS equivalent of C<undef(@array)>.
532 As well as freeing all the elements of the array (like C<av_clear()>), this
533 also frees the memory used by the av to store its list of scalars.
535 See L</av_clear> for a note about the array possibly being invalid on
542 Perl_av_undef(pTHX_ AV *av)
547 PERL_ARGS_ASSERT_AV_UNDEF;
548 assert(SvTYPE(av) == SVt_PVAV);
550 /* Give any tie a chance to cleanup first */
551 if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
554 if ((real = cBOOL(AvREAL(av)))) {
555 SSize_t key = AvFILLp(av) + 1;
557 /* avoid av being freed when calling destructors below */
559 PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
560 orig_ix = PL_tmps_ix;
563 SvREFCNT_dec(AvARRAY(av)[--key]);
566 Safefree(AvALLOC(av));
569 AvMAX(av) = AvFILLp(av) = -1;
571 if(SvRMAGICAL(av)) mg_clear(MUTABLE_SV(av));
573 /* disarm av's premature free guard */
574 if (LIKELY(PL_tmps_ix == orig_ix))
577 PL_tmps_stack[orig_ix] = &PL_sv_undef;
584 =for apidoc av_create_and_push
586 Push an SV onto the end of the array, creating the array if necessary.
587 A small internal helper function to remove a commonly duplicated idiom.
593 Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val)
595 PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH;
605 Pushes an SV (transferring control of one reference count) onto the end of the
606 array. The array will grow automatically to accommodate the addition.
608 Perl equivalent: C<push @myarray, $val;>.
614 Perl_av_push(pTHX_ AV *av, SV *val)
618 PERL_ARGS_ASSERT_AV_PUSH;
619 assert(SvTYPE(av) == SVt_PVAV);
622 Perl_croak_no_modify();
624 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
625 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(PUSH), G_DISCARD, 1,
629 av_store(av,AvFILLp(av)+1,val);
635 Removes one SV from the end of the array, reducing its size by one and
636 returning the SV (transferring control of one reference count) to the
637 caller. Returns C<&PL_sv_undef> if the array is empty.
639 Perl equivalent: C<pop(@myarray);>
645 Perl_av_pop(pTHX_ AV *av)
650 PERL_ARGS_ASSERT_AV_POP;
651 assert(SvTYPE(av) == SVt_PVAV);
654 Perl_croak_no_modify();
655 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
656 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(POP), 0, 0);
658 retval = newSVsv(retval);
663 retval = AvARRAY(av)[AvFILLp(av)];
664 AvARRAY(av)[AvFILLp(av)--] = NULL;
666 mg_set(MUTABLE_SV(av));
667 return retval ? retval : &PL_sv_undef;
672 =for apidoc av_create_and_unshift_one
674 Unshifts an SV onto the beginning of the array, creating the array if
676 A small internal helper function to remove a commonly duplicated idiom.
682 Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val)
684 PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE;
689 return av_store(*avp, 0, val);
693 =for apidoc av_unshift
695 Unshift the given number of C<undef> values onto the beginning of the
696 array. The array will grow automatically to accommodate the addition.
698 Perl equivalent: S<C<unshift @myarray, ((undef) x $num);>>
704 Perl_av_unshift(pTHX_ AV *av, SSize_t num)
709 PERL_ARGS_ASSERT_AV_UNSHIFT;
710 assert(SvTYPE(av) == SVt_PVAV);
713 Perl_croak_no_modify();
715 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
716 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(UNSHIFT),
717 G_DISCARD | G_UNDEF_FILL, num);
723 if (!AvREAL(av) && AvREIFY(av))
725 i = AvARRAY(av) - AvALLOC(av);
733 AvARRAY(av) = AvARRAY(av) - i;
737 const SSize_t i = AvFILLp(av);
738 /* Create extra elements */
739 const SSize_t slide = i > 0 ? i : 0;
741 av_extend(av, i + num);
744 Move(ary, ary + num, i + 1, SV*);
748 /* Make extra elements into a buffer */
750 AvFILLp(av) -= slide;
751 AvARRAY(av) = AvARRAY(av) + slide;
758 Removes one SV from the start of the array, reducing its size by one and
759 returning the SV (transferring control of one reference count) to the
760 caller. Returns C<&PL_sv_undef> if the array is empty.
762 Perl equivalent: C<shift(@myarray);>
768 Perl_av_shift(pTHX_ AV *av)
773 PERL_ARGS_ASSERT_AV_SHIFT;
774 assert(SvTYPE(av) == SVt_PVAV);
777 Perl_croak_no_modify();
778 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
779 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(SHIFT), 0, 0);
781 retval = newSVsv(retval);
786 retval = *AvARRAY(av);
789 AvARRAY(av) = AvARRAY(av) + 1;
793 mg_set(MUTABLE_SV(av));
794 return retval ? retval : &PL_sv_undef;
798 =for apidoc av_top_index
800 Returns the highest index in the array. The number of elements in the
801 array is S<C<av_top_index(av) + 1>>. Returns -1 if the array is empty.
803 The Perl equivalent for this is C<$#myarray>.
805 (A slightly shorter form is C<av_tindex>.)
809 Same as L</av_top_index>. Note that, unlike what the name implies, it returns
810 the highest index in the array, so to get the size of the array you need to use
811 S<C<av_len(av) + 1>>. This is unlike L</sv_len>, which returns what you would
818 Perl_av_len(pTHX_ AV *av)
820 PERL_ARGS_ASSERT_AV_LEN;
822 return av_top_index(av);
828 Set the highest index in the array to the given number, equivalent to
829 Perl's S<C<$#array = $fill;>>.
831 The number of elements in the array will be S<C<fill + 1>> after
832 C<av_fill()> returns. If the array was previously shorter, then the
833 additional elements appended are set to NULL. If the array
834 was longer, then the excess elements are freed. S<C<av_fill(av, -1)>> is
835 the same as C<av_clear(av)>.
840 Perl_av_fill(pTHX_ AV *av, SSize_t fill)
844 PERL_ARGS_ASSERT_AV_FILL;
845 assert(SvTYPE(av) == SVt_PVAV);
849 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
850 SV *arg1 = sv_newmortal();
851 sv_setiv(arg1, (IV)(fill + 1));
852 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(STORESIZE), G_DISCARD,
856 if (fill <= AvMAX(av)) {
857 SSize_t key = AvFILLp(av);
858 SV** const ary = AvARRAY(av);
862 SvREFCNT_dec(ary[key]);
873 mg_set(MUTABLE_SV(av));
876 (void)av_store(av,fill,NULL);
880 =for apidoc av_delete
882 Deletes the element indexed by C<key> from the array, makes the element
883 mortal, and returns it. If C<flags> equals C<G_DISCARD>, the element is
884 freed and NULL is returned. NULL is also returned if C<key> is out of
887 Perl equivalent: S<C<splice(@myarray, $key, 1, undef)>> (with the
888 C<splice> in void context if C<G_DISCARD> is present).
893 Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
897 PERL_ARGS_ASSERT_AV_DELETE;
898 assert(SvTYPE(av) == SVt_PVAV);
901 Perl_croak_no_modify();
903 if (SvRMAGICAL(av)) {
904 const MAGIC * const tied_magic
905 = mg_find((const SV *)av, PERL_MAGIC_tied);
906 if ((tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata))) {
909 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
912 svp = av_fetch(av, key, TRUE);
916 if (mg_find(sv, PERL_MAGIC_tiedelem)) {
917 sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
926 key += AvFILL(av) + 1;
931 if (key > AvFILLp(av))
934 if (!AvREAL(av) && AvREIFY(av))
936 sv = AvARRAY(av)[key];
937 AvARRAY(av)[key] = NULL;
938 if (key == AvFILLp(av)) {
941 } while (--key >= 0 && !AvARRAY(av)[key]);
944 mg_set(MUTABLE_SV(av));
947 if (flags & G_DISCARD) {
958 =for apidoc av_exists
960 Returns true if the element indexed by C<key> has been initialized.
962 This relies on the fact that uninitialized array elements are set to
965 Perl equivalent: C<exists($myarray[$key])>.
970 Perl_av_exists(pTHX_ AV *av, SSize_t key)
972 PERL_ARGS_ASSERT_AV_EXISTS;
973 assert(SvTYPE(av) == SVt_PVAV);
975 if (SvRMAGICAL(av)) {
976 const MAGIC * const tied_magic
977 = mg_find((const SV *)av, PERL_MAGIC_tied);
978 const MAGIC * const regdata_magic
979 = mg_find((const SV *)av, PERL_MAGIC_regdata);
980 if (tied_magic || regdata_magic) {
982 /* Handle negative array indices 20020222 MJD */
984 if (!S_adjust_index(aTHX_ av, tied_magic, &key))
988 if(key >= 0 && regdata_magic) {
989 if (key <= AvFILL(av))
995 SV * const sv = sv_newmortal();
996 mg_copy(MUTABLE_SV(av), sv, 0, key);
997 mg = mg_find(sv, PERL_MAGIC_tiedelem);
999 magic_existspack(sv, mg);
1001 I32 retbool = SvTRUE_nomg_NN(sv);
1002 return cBOOL(retbool);
1010 key += AvFILL(av) + 1;
1015 if (key <= AvFILLp(av) && AvARRAY(av)[key])
1024 S_get_aux_mg(pTHX_ AV *av) {
1027 PERL_ARGS_ASSERT_GET_AUX_MG;
1028 assert(SvTYPE(av) == SVt_PVAV);
1030 mg = mg_find((const SV *)av, PERL_MAGIC_arylen_p);
1033 mg = sv_magicext(MUTABLE_SV(av), 0, PERL_MAGIC_arylen_p,
1034 &PL_vtbl_arylen_p, 0, 0);
1036 /* sv_magicext won't set this for us because we pass in a NULL obj */
1037 mg->mg_flags |= MGf_REFCOUNTED;
1043 Perl_av_arylen_p(pTHX_ AV *av) {
1044 MAGIC *const mg = get_aux_mg(av);
1046 PERL_ARGS_ASSERT_AV_ARYLEN_P;
1047 assert(SvTYPE(av) == SVt_PVAV);
1049 return &(mg->mg_obj);
1053 Perl_av_iter_p(pTHX_ AV *av) {
1054 MAGIC *const mg = get_aux_mg(av);
1056 PERL_ARGS_ASSERT_AV_ITER_P;
1057 assert(SvTYPE(av) == SVt_PVAV);
1059 #if IVSIZE == I32SIZE
1060 return (IV *)&(mg->mg_len);
1064 mg->mg_len = IVSIZE;
1066 mg->mg_ptr = (char *) temp;
1068 return (IV *)mg->mg_ptr;
1073 * ex: set ts=8 sts=4 sw=4 et: