/*    av.c
		 *
		 *    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.
		 *
		 */
		
		/*
		 * "...for the Entwives desired order, and plenty, and peace (by which they
		 * meant that things should remain where they had set them)." --Treebeard
		 */
		
		/*
		=head1 Array Manipulation Functions
		*/
		
		#include "EXTERN.h"
		#define PERL_IN_AV_C
		#include "perl.h"
		
		void
		Perl_av_reify(pTHX_ AV *av)
       13087    {
       13087        I32 key;
		
       13087        if (AvREAL(av))
      ######    	return;
		#ifdef DEBUGGING
       13087        if (SvTIED_mg((SV*)av, PERL_MAGIC_tied) && ckWARN_d(WARN_DEBUGGING))
      ######    	Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
		#endif
       13087        key = AvMAX(av) + 1;
       91730        while (key > AvFILLp(av) + 1)
       78643    	AvARRAY(av)[--key] = &PL_sv_undef;
       14448        while (key) {
        1361    	SV * const sv = AvARRAY(av)[--key];
        1361    	assert(sv);
        1361    	if (sv != &PL_sv_undef)
        1359    	    (void)SvREFCNT_inc(sv);
		    }
       13087        key = AvARRAY(av) - AvALLOC(av);
       16643        while (key)
        3556    	AvALLOC(av)[--key] = &PL_sv_undef;
       13087        AvREIFY_off(av);
       13087        AvREAL_on(av);
		}
		
		/*
		=for apidoc av_extend
		
		Pre-extend an array.  The C<key> is the index to which the array should be
		extended.
		
		=cut
		*/
		
		void
		Perl_av_extend(pTHX_ AV *av, I32 key)
     4460176    {
     4460176        MAGIC *mg;
     4460176        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
         123    	dSP;
         123    	ENTER;
         123    	SAVETMPS;
         123    	PUSHSTACKi(PERLSI_MAGIC);
         123    	PUSHMARK(SP);
         123    	EXTEND(SP,2);
         123    	PUSHs(SvTIED_obj((SV*)av, mg));
         123    	PUSHs(sv_2mortal(newSViv(key+1)));
         123            PUTBACK;
         123    	call_method("EXTEND", G_SCALAR|G_DISCARD);
         123    	POPSTACK;
         123    	FREETMPS;
         123    	LEAVE;
         123    	return;
		    }
     4460053        if (key > AvMAX(av)) {
     3481376    	SV** ary;
     3481376    	I32 tmp;
     3481376    	I32 newmax;
		
     3481376    	if (AvALLOC(av) != AvARRAY(av)) {
        8082    	    ary = AvALLOC(av) + AvFILLp(av) + 1;
        8082    	    tmp = AvARRAY(av) - AvALLOC(av);
        8082    	    Move(AvARRAY(av), AvALLOC(av), AvFILLp(av)+1, SV*);
        8082    	    AvMAX(av) += tmp;
        8082    	    SvPV_set(av, (char*)AvALLOC(av));
        8082    	    if (AvREAL(av)) {
       46366    		while (tmp)
       38284    		    ary[--tmp] = &PL_sv_undef;
			    }
			    
        8082    	    if (key > AvMAX(av) - 10) {
        7752    		newmax = key + AvMAX(av);
        7752    		goto resize;
			    }
			}
			else {
		#ifdef PERL_MALLOC_WRAP
			    static const char oom_array_extend[] =
     3473294    	      "Out of memory during array extend"; /* Duplicated in pp_hot.c */
		#endif
		
     3473294    	    if (AvALLOC(av)) {
		#if !defined(STRANGE_MALLOC) && !defined(MYMALLOC)
      873733    		MEM_SIZE bytes;
      873733    		IV itmp;
		#endif
		
		#ifdef MYMALLOC
				newmax = malloced_size((void*)AvALLOC(av))/sizeof(SV*) - 1;
		
				if (key <= newmax) 
				    goto resized;
		#endif 
      873733    		newmax = key + AvMAX(av) / 5;
			      resize:
      881485    		MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
		#if defined(STRANGE_MALLOC) || defined(MYMALLOC)
				Renew(AvALLOC(av),newmax+1, SV*);
		#else
      881485    		bytes = (newmax + 1) * sizeof(SV*);
		#define MALLOC_OVERHEAD 16
      881485    		itmp = MALLOC_OVERHEAD;
     3222859    		while ((MEM_SIZE)(itmp - MALLOC_OVERHEAD) < bytes)
     2341374    		    itmp += itmp;
      881485    		itmp -= MALLOC_OVERHEAD;
      881485    		itmp /= sizeof(SV*);
      881485    		assert(itmp > newmax);
      881485    		newmax = itmp - 1;
      881485    		assert(newmax >= AvMAX(av));
      881485    		New(2,ary, newmax+1, SV*);
      881485    		Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
      881485    		if (AvMAX(av) > 64)
       10729    		    offer_nice_chunk(AvALLOC(av), (AvMAX(av)+1) * sizeof(SV*));
				else
      870756    		    Safefree(AvALLOC(av));
      881485    		AvALLOC(av) = ary;
		#endif
		#ifdef MYMALLOC
			      resized:
		#endif
      881485    		ary = AvALLOC(av) + AvMAX(av) + 1;
      881485    		tmp = newmax - AvMAX(av);
      881485    		if (av == PL_curstack) {	/* Oops, grew stack (via av_store()?) */
        1207    		    PL_stack_sp = AvALLOC(av) + (PL_stack_sp - PL_stack_base);
        1207    		    PL_stack_base = AvALLOC(av);
        1207    		    PL_stack_max = PL_stack_base + newmax;
				}
			    }
			    else {
     2599561    		newmax = key < 3 ? 3 : key;
     2599561    		MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
     2599560    		New(2,AvALLOC(av), newmax+1, SV*);
     2599560    		ary = AvALLOC(av) + 1;
     2599560    		tmp = newmax;
     2599560    		AvALLOC(av)[0] = &PL_sv_undef;	/* For the stacks */
			    }
     3481045    	    if (AvREAL(av)) {
    25347561    		while (tmp)
    22402603    		    ary[--tmp] = &PL_sv_undef;
			    }
			    
     3481045    	    SvPV_set(av, (char*)AvALLOC(av));
     3481045    	    AvMAX(av) = newmax;
			}
		    }
		}
		
		/*
		=for apidoc av_fetch
		
		Returns the SV at the specified index in the array.  The C<key> is the
		index.  If C<lval> is set then the fetch will be part of a store.  Check
		that the return value is non-null before dereferencing it to a C<SV*>.
		
		See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
		more information on how to use this function on tied arrays. 
		
		=cut
		*/
		
		SV**
		Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval)
    22091294    {
    22091294        SV *sv;
		
    22091294        if (!av)
      ######    	return 0;
		
    22091294        if (SvRMAGICAL(av)) {
     1237353            const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
     1237353            if (tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata)) {
        3773                U32 adjust_index = 1;
		
        3773                if (tied_magic && key < 0) {
		                /* Handle negative array indices 20020222 MJD */
          10                    SV **negative_indices_glob = 
		                    hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
		                                                     tied_magic))), 
          10                                 NEGATIVE_INDICES_VAR, 16, 0);
		
          10                    if (negative_indices_glob
      ######                        && SvTRUE(GvSV(*negative_indices_glob)))
          10                        adjust_index = 0;
		            }
		
        3773                if (key < 0 && adjust_index) {
      ######                    key += AvFILL(av) + 1;
      ######                    if (key < 0)
      ######                        return 0;
		            }
		
        3773                sv = sv_newmortal();
        3773    	    sv_upgrade(sv, SVt_PVLV);
        3773    	    mg_copy((SV*)av, sv, 0, key);
        3773    	    LvTYPE(sv) = 't';
        3773    	    LvTARG(sv) = sv; /* fake (SV**) */
        3773    	    return &(LvTARG(sv));
		        }
		    }
		
    22087521        if (key < 0) {
      822389    	key += AvFILL(av) + 1;
      822389    	if (key < 0)
       18016    	    return 0;
		    }
		
    22069505        if (key > AvFILLp(av)) {
     5274714    	if (!lval)
       58669    	    return 0;
     5216045    	sv = NEWSV(5,0);
     5216045    	return av_store(av,key,sv);
		    }
    16794791        if (AvARRAY(av)[key] == &PL_sv_undef) {
		    emptyness:
       79114    	if (lval) {
       78303    	    sv = NEWSV(6,0);
       78303    	    return av_store(av,key,sv);
			}
         811    	return 0;
		    }
    16715686        else if (AvREIFY(av)
			     && (!AvARRAY(av)[key]	/* eg. @_ could have freed elts */
				 || SvTYPE(AvARRAY(av)[key]) == SVTYPEMASK)) {
           9    	AvARRAY(av)[key] = &PL_sv_undef;	/* 1/2 reify */
           9    	goto emptyness;
		    }
    16715677        return &AvARRAY(av)[key];
		}
		
		/*
		=for apidoc av_store
		
		Stores an SV in an array.  The array index is specified as C<key>.  The
		return value will be NULL if the operation failed or if the value did not
		need to be actually stored within the array (as in the case of tied
		arrays). Otherwise it can be dereferenced to get the original C<SV*>.  Note
		that the caller is responsible for suitably incrementing the reference
		count of C<val> before the call, and decrementing it if the function
		returned NULL.
		
		See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
		more information on how to use this function on tied arrays.
		
		=cut
		*/
		
		SV**
		Perl_av_store(pTHX_ register AV *av, I32 key, SV *val)
    14689558    {
    14689558        SV** ary;
		
    14689558        if (!av)
      ######    	return 0;
    14689558        if (!val)
     1009386    	val = &PL_sv_undef;
		
    14689558        if (SvRMAGICAL(av)) {
      243722            const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
      243722            if (tied_magic) {
		            /* Handle negative array indices 20020222 MJD */
         528                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;
		                }
		            }
         528    	    if (val != &PL_sv_undef) {
         528    		mg_copy((SV*)av, val, 0, key);
			    }
         528    	    return 0;
		        }
		    }
		
		
    14689030        if (key < 0) {
      ######    	key += AvFILL(av) + 1;
      ######    	if (key < 0)
      ######    	    return 0;
		    }
		
    14689030        if (SvREADONLY(av) && key >= AvFILL(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
		
    14689030        if (!AvREAL(av) && AvREIFY(av))
       11924    	av_reify(av);
    14689030        if (key > AvMAX(av))
     2540875    	av_extend(av,key);
    14689029        ary = AvARRAY(av);
    14689029        if (AvFILLp(av) < key) {
    13517319    	if (!AvREAL(av)) {
     1125037    	    if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
      ######    		PL_stack_sp = PL_stack_base + key;	/* XPUSH in disguise */
     1125037    	    do
     1125037    		ary[++AvFILLp(av)] = &PL_sv_undef;
			    while (AvFILLp(av) < key);
			}
    13517319    	AvFILLp(av) = key;
		    }
     1171710        else if (AvREAL(av))
     1171710    	SvREFCNT_dec(ary[key]);
    14689029        ary[key] = val;
    14689029        if (SvSMAGICAL(av)) {
       14782    	if (val != &PL_sv_undef) {
       14782    	    MAGIC* mg = SvMAGIC(av);
       14782    	    sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
			}
       14782    	mg_set((SV*)av);
		    }
    14689029        return &ary[key];
		}
		
		/*
		=for apidoc newAV
		
		Creates a new AV.  The reference count is set to 1.
		
		=cut
		*/
		
		AV *
		Perl_newAV(pTHX)
     2866498    {
     2866498        register AV *av;
		
     2866498        av = (AV*)NEWSV(3,0);
     2866498        sv_upgrade((SV *)av, SVt_PVAV);
		    /* sv_upgrade does AvREAL_only()  */
     2866498        AvALLOC(av) = 0;
     2866498        SvPV_set(av, (char*)0);
     2866498        AvMAX(av) = AvFILLp(av) = -1;
     2866498        return av;
		}
		
		/*
		=for apidoc av_make
		
		Creates a new AV and populates it with a list of SVs.  The SVs are copied
		into the array, so they may be freed after the call to av_make.  The new AV
		will have a reference count of 1.
		
		=cut
		*/
		
		AV *
		Perl_av_make(pTHX_ register I32 size, register SV **strp)
     1199280    {
     1199280        register AV *av;
		
     1199280        av = (AV*)NEWSV(8,0);
     1199280        sv_upgrade((SV *) av,SVt_PVAV);
		    /* sv_upgrade does AvREAL_only()  */
     1199280        if (size) {		/* "defined" was returning undef for size==0 anyway. */
     1154734            register SV** ary;
     1154734            register I32 i;
     1154734    	New(4,ary,size,SV*);
     1154734    	AvALLOC(av) = ary;
     1154734    	SvPV_set(av, (char*)ary);
     1154734    	AvFILLp(av) = size - 1;
     1154734    	AvMAX(av) = size - 1;
     5434476    	for (i = 0; i < size; i++) {
     4279742    	    assert (*strp);
     4279742    	    ary[i] = NEWSV(7,0);
     4279742    	    sv_setsv(ary[i], *strp);
     4279742    	    strp++;
			}
		    }
     1199280        return av;
		}
		
		AV *
		Perl_av_fake(pTHX_ register I32 size, register SV **strp)
      ######    {
      ######        register AV *av;
      ######        register SV** ary;
		
      ######        av = (AV*)NEWSV(9,0);
      ######        sv_upgrade((SV *)av, SVt_PVAV);
      ######        New(4,ary,size+1,SV*);
      ######        AvALLOC(av) = ary;
      ######        Copy(strp,ary,size,SV*);
      ######        AvREIFY_only(av);
      ######        SvPV_set(av, (char*)ary);
      ######        AvFILLp(av) = size - 1;
      ######        AvMAX(av) = size - 1;
      ######        while (size--) {
      ######    	assert (*strp);
      ######    	SvTEMP_off(*strp);
      ######    	strp++;
		    }
      ######        return av;
		}
		
		/*
		=for apidoc av_clear
		
		Clears an array, making it empty.  Does not free the memory used by the
		array itself.
		
		=cut
		*/
		
		void
		Perl_av_clear(pTHX_ register AV *av)
     2270433    {
     2270433        register I32 key;
		
		#ifdef DEBUGGING
     2270433        if (SvREFCNT(av) == 0 && ckWARN_d(WARN_DEBUGGING)) {
      ######    	Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
		    }
		#endif
     2270433        if (!av)
      ######    	return;
		
     2270433        if (SvREADONLY(av))
           2    	Perl_croak(aTHX_ PL_no_modify);
		
		    /* Give any tie a chance to cleanup first */
     2270431        if (SvRMAGICAL(av))
       23538    	mg_clear((SV*)av); 
		
     2270431        if (AvMAX(av) < 0)
      443712    	return;
		
     1826719        if (AvREAL(av)) {
     1816780            SV** ary = AvARRAY(av);
     1816780    	key = AvFILLp(av) + 1;
     4669833    	while (key) {
     2853053    	    SV * sv = ary[--key];
			    /* undef the slot before freeing the value, because a
			     * destructor might try to modify this arrray */
     2853053    	    ary[key] = &PL_sv_undef;
     2853053    	    SvREFCNT_dec(sv);
			}
		    }
     1826719        if ((key = AvARRAY(av) - AvALLOC(av))) {
       25294    	AvMAX(av) += key;
       25294    	SvPV_set(av, (char*)AvALLOC(av));
		    }
     1826719        AvFILLp(av) = -1;
		
		}
		
		/*
		=for apidoc av_undef
		
		Undefines the array.  Frees the memory used by the array itself.
		
		=cut
		*/
		
		void
		Perl_av_undef(pTHX_ register AV *av)
     4083372    {
     4083372        if (!av)
      ######    	return;
		
		    /* Give any tie a chance to cleanup first */
     4083372        if (SvTIED_mg((SV*)av, PERL_MAGIC_tied)) 
      ######    	av_fill(av, -1);   /* mg_clear() ? */
		
     4083372        if (AvREAL(av)) {
     3111524    	register I32 key = AvFILLp(av) + 1;
    21700511    	while (key)
    18588987    	    SvREFCNT_dec(AvARRAY(av)[--key]);
		    }
     4083372        Safefree(AvALLOC(av));
     4083372        AvALLOC(av) = 0;
     4083372        SvPV_set(av, (char*)0);
     4083372        AvMAX(av) = AvFILLp(av) = -1;
		    /* It's in magic - it must already be gone.  */
     4083372        assert (!AvARYLEN(av));
		}
		
		/*
		=for apidoc av_push
		
		Pushes an SV onto the end of the array.  The array will grow automatically
		to accommodate the addition.
		
		=cut
		*/
		
		void
		Perl_av_push(pTHX_ register AV *av, SV *val)
     1710536    {             
		    dVAR;
     1710536        MAGIC *mg;
     1710536        if (!av)
      ######    	return;
     1710536        if (SvREADONLY(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
		
     1710536        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
      ######    	dSP;
      ######    	PUSHSTACKi(PERLSI_MAGIC);
      ######    	PUSHMARK(SP);
      ######    	EXTEND(SP,2);
      ######    	PUSHs(SvTIED_obj((SV*)av, mg));
      ######    	PUSHs(val);
      ######    	PUTBACK;
      ######    	ENTER;
      ######    	call_method("PUSH", G_SCALAR|G_DISCARD);
      ######    	LEAVE;
      ######    	POPSTACK;
      ######    	return;
		    }
     1710536        av_store(av,AvFILLp(av)+1,val);
		}
		
		/*
		=for apidoc av_pop
		
		Pops an SV off the end of the array.  Returns C<&PL_sv_undef> if the array
		is empty.
		
		=cut
		*/
		
		SV *
		Perl_av_pop(pTHX_ register AV *av)
       68683    {
		    dVAR;
       68683        SV *retval;
       68683        MAGIC* mg;
		
       68683        if (!av)
      ######          return &PL_sv_undef;
       68683        if (SvREADONLY(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
       68683        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
           9    	dSP;    
           9    	PUSHSTACKi(PERLSI_MAGIC);
           9    	PUSHMARK(SP);
           9    	XPUSHs(SvTIED_obj((SV*)av, mg));
           9    	PUTBACK;
           9    	ENTER;
           9    	if (call_method("POP", G_SCALAR)) {
           9    	    retval = newSVsv(*PL_stack_sp--);    
			} else {    
      ######    	    retval = &PL_sv_undef;
			}
           9    	LEAVE;
           9    	POPSTACK;
           9    	return retval;
		    }
       68674        if (AvFILL(av) < 0)
        1291    	return &PL_sv_undef;
       67383        retval = AvARRAY(av)[AvFILLp(av)];
       67383        AvARRAY(av)[AvFILLp(av)--] = &PL_sv_undef;
       67383        if (SvSMAGICAL(av))
      ######    	mg_set((SV*)av);
       67383        return retval;
		}
		
		/*
		=for apidoc av_unshift
		
		Unshift the given number of C<undef> values onto the beginning of the
		array.  The array will grow automatically to accommodate the addition.  You
		must then use C<av_store> to assign values to these new elements.
		
		=cut
		*/
		
		void
		Perl_av_unshift(pTHX_ register AV *av, register I32 num)
       52910    {
		    dVAR;
       52910        register I32 i;
       52910        MAGIC* mg;
		
       52910        if (!av)
      ######    	return;
       52910        if (SvREADONLY(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
		
       52910        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
      ######    	dSP;
      ######    	PUSHSTACKi(PERLSI_MAGIC);
      ######    	PUSHMARK(SP);
      ######    	EXTEND(SP,1+num);
      ######    	PUSHs(SvTIED_obj((SV*)av, mg));
      ######    	while (num-- > 0) {
      ######    	    PUSHs(&PL_sv_undef);
			}
      ######    	PUTBACK;
      ######    	ENTER;
      ######    	call_method("UNSHIFT", G_SCALAR|G_DISCARD);
      ######    	LEAVE;
      ######    	POPSTACK;
      ######    	return;
		    }
		
       52910        if (num <= 0)
          62          return;
       52848        if (!AvREAL(av) && AvREIFY(av))
        1073    	av_reify(av);
       52848        i = AvARRAY(av) - AvALLOC(av);
       52848        if (i) {
       19547    	if (i > num)
       11929    	    i = num;
       19547    	num -= i;
		    
       19547    	AvMAX(av) += i;
       19547    	AvFILLp(av) += i;
       19547    	SvPV_set(av, (char*)(AvARRAY(av) - i));
		    }
       52848        if (num) {
       33472    	register SV **ary;
       33472    	I32 slide;
       33472    	i = AvFILLp(av);
			/* Create extra elements */
       33472    	slide = i > 0 ? i : 0;
       33472    	num += slide;
       33472    	av_extend(av, i + num);
       33472    	AvFILLp(av) += num;
       33472    	ary = AvARRAY(av);
       33472    	Move(ary, ary + num, i + 1, SV*);
       96019    	do {
       96019    	    ary[--num] = &PL_sv_undef;
       96019    	} while (num);
			/* Make extra elements into a buffer */
       33472    	AvMAX(av) -= slide;
       33472    	AvFILLp(av) -= slide;
       33472    	SvPV_set(av, (char*)(AvARRAY(av) + slide));
		    }
		}
		
		/*
		=for apidoc av_shift
		
		Shifts an SV off the beginning of the array.
		
		=cut
		*/
		
		SV *
		Perl_av_shift(pTHX_ register AV *av)
    16087131    {
		    dVAR;
    16087131        SV *retval;
    16087131        MAGIC* mg;
		
    16087131        if (!av)
      ######    	return &PL_sv_undef;
    16087131        if (SvREADONLY(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
    16087131        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
           9    	dSP;
           9    	PUSHSTACKi(PERLSI_MAGIC);
           9    	PUSHMARK(SP);
           9    	XPUSHs(SvTIED_obj((SV*)av, mg));
           9    	PUTBACK;
           9    	ENTER;
           9    	if (call_method("SHIFT", G_SCALAR)) {
           9    	    retval = newSVsv(*PL_stack_sp--);            
			} else {    
      ######    	    retval = &PL_sv_undef;
			}     
           9    	LEAVE;
           9    	POPSTACK;
           9    	return retval;
		    }
    16087122        if (AvFILL(av) < 0)
      189257          return &PL_sv_undef;
    15897865        retval = *AvARRAY(av);
    15897865        if (AvREAL(av))
      151422    	*AvARRAY(av) = &PL_sv_undef;
    15897865        SvPV_set(av, (char*)(AvARRAY(av) + 1));
    15897865        AvMAX(av)--;
    15897865        AvFILLp(av)--;
    15897865        if (SvSMAGICAL(av))
      ######    	mg_set((SV*)av);
    15897865        return retval;
		}
		
		/*
		=for apidoc av_len
		
		Returns the highest index in the array.  Returns -1 if the array is
		empty.
		
		=cut
		*/
		
		I32
		Perl_av_len(pTHX_ const register AV *av)
      844748    {
      844748        return AvFILL(av);
		}
		
		/*
		=for apidoc av_fill
		
		Ensure than an array has a given number of elements, equivalent to
		Perl's C<$#array = $fill;>.
		
		=cut
		*/
		void
		Perl_av_fill(pTHX_ register AV *av, I32 fill)
       15849    {
		    dVAR;
       15849        MAGIC *mg;
       15849        if (!av)
      ######    	Perl_croak(aTHX_ "panic: null array");
       15849        if (fill < 0)
          46    	fill = -1;
       15849        if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
          20    	dSP;            
          20    	ENTER;
          20    	SAVETMPS;
          20    	PUSHSTACKi(PERLSI_MAGIC);
          20    	PUSHMARK(SP);
          20    	EXTEND(SP,2);
          20    	PUSHs(SvTIED_obj((SV*)av, mg));
          20    	PUSHs(sv_2mortal(newSViv(fill+1)));
          20    	PUTBACK;
          20    	call_method("STORESIZE", G_SCALAR|G_DISCARD);
          20    	POPSTACK;
          20    	FREETMPS;
          20    	LEAVE;
          20    	return;
		    }
       15829        if (fill <= AvMAX(av)) {
        8626    	I32 key = AvFILLp(av);
        8626    	SV** ary = AvARRAY(av);
		
        8626    	if (AvREAL(av)) {
        9975    	    while (key > fill) {
        1349    		SvREFCNT_dec(ary[key]);
        1349    		ary[key--] = &PL_sv_undef;
			    }
			}
			else {
      ######    	    while (key < fill)
      ######    		ary[++key] = &PL_sv_undef;
			}
			    
        8626    	AvFILLp(av) = fill;
        8626    	if (SvSMAGICAL(av))
           1    	    mg_set((SV*)av);
		    }
		    else
        7203    	(void)av_store(av,fill,&PL_sv_undef);
		}
		
		/*
		=for apidoc av_delete
		
		Deletes the element indexed by C<key> from the array.  Returns the
		deleted element. If C<flags> equals C<G_DISCARD>, the element is freed
		and null is returned.
		
		=cut
		*/
		SV *
		Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
          33    {
          33        SV *sv;
		
          33        if (!av)
      ######    	return Nullsv;
          33        if (SvREADONLY(av))
      ######    	Perl_croak(aTHX_ PL_no_modify);
		
          33        if (SvRMAGICAL(av)) {
          18            const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
          18            if ((tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata))) {
		            /* Handle negative array indices 20020222 MJD */
          14                SV **svp;
          14                if (key < 0) {
           2                    unsigned adjust_index = 1;
           2                    if (tied_magic) {
           2                        SV **negative_indices_glob = 
		                        hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
		                                                         tied_magic))), 
           2                                     NEGATIVE_INDICES_VAR, 16, 0);
           2                        if (negative_indices_glob
      ######                            && SvTRUE(GvSV(*negative_indices_glob)))
           2                            adjust_index = 0;
		                }
           2                    if (adjust_index) {
      ######                        key += AvFILL(av) + 1;
      ######                        if (key < 0)
      ######                            return Nullsv;
		                }
		            }
          14                svp = av_fetch(av, key, TRUE);
          14                if (svp) {
          14                    sv = *svp;
          14                    mg_clear(sv);
          14                    if (mg_find(sv, PERL_MAGIC_tiedelem)) {
          14                        sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
          14                        return sv;
		                }
      ######                    return Nullsv;     
		            }
		        }
		    }
		
          19        if (key < 0) {
      ######    	key += AvFILL(av) + 1;
      ######    	if (key < 0)
      ######    	    return Nullsv;
		    }
		
          19        if (key > AvFILLp(av))
           3    	return Nullsv;
		    else {
          16    	if (!AvREAL(av) && AvREIFY(av))
           1    	    av_reify(av);
          16    	sv = AvARRAY(av)[key];
          16    	if (key == AvFILLp(av)) {
           7    	    AvARRAY(av)[key] = &PL_sv_undef;
          17    	    do {
          17    		AvFILLp(av)--;
          17    	    } while (--key >= 0 && AvARRAY(av)[key] == &PL_sv_undef);
			}
			else
           9    	    AvARRAY(av)[key] = &PL_sv_undef;
          16    	if (SvSMAGICAL(av))
      ######    	    mg_set((SV*)av);
		    }
          16        if (flags & G_DISCARD) {
           6    	SvREFCNT_dec(sv);
           6    	sv = Nullsv;
		    }
          10        else if (AvREAL(av))
          10    	sv = sv_2mortal(sv);
          16        return sv;
		}
		
		/*
		=for apidoc av_exists
		
		Returns true if the element indexed by C<key> has been initialized.
		
		This relies on the fact that uninitialized array elements are set to
		C<&PL_sv_undef>.
		
		=cut
		*/
		bool
		Perl_av_exists(pTHX_ AV *av, I32 key)
         124    {
         124        if (!av)
      ######    	return FALSE;
		
		
         124        if (SvRMAGICAL(av)) {
         109            const MAGIC * const tied_magic = mg_find((SV*)av, PERL_MAGIC_tied);
         109            if (tied_magic || mg_find((SV*)av, PERL_MAGIC_regdata)) {
          22                SV *sv = sv_newmortal();
          22                MAGIC *mg;
		            /* Handle negative array indices 20020222 MJD */
          22                if (key < 0) {
           8                    unsigned adjust_index = 1;
           8                    if (tied_magic) {
           8                        SV **negative_indices_glob = 
		                        hv_fetch(SvSTASH(SvRV(SvTIED_obj((SV *)av, 
		                                                         tied_magic))), 
           8                                     NEGATIVE_INDICES_VAR, 16, 0);
           8                        if (negative_indices_glob
      ######                            && SvTRUE(GvSV(*negative_indices_glob)))
           4                            adjust_index = 0;
		                }
           8                    if (adjust_index) {
           4                        key += AvFILL(av) + 1;
           4                        if (key < 0)
           1                            return FALSE;
		                }
		            }
		
          21                mg_copy((SV*)av, sv, 0, key);
          21                mg = mg_find(sv, PERL_MAGIC_tiedelem);
          21                if (mg) {
          21                    magic_existspack(sv, mg);
          21                    return (bool)SvTRUE(sv);
		            }
		
		        }
		    }
		
         102        if (key < 0) {
      ######    	key += AvFILL(av) + 1;
      ######    	if (key < 0)
      ######    	    return FALSE;
		    }
		
         102        if (key <= AvFILLp(av) && AvARRAY(av)[key] != &PL_sv_undef
			&& AvARRAY(av)[key])
		    {
          88    	return TRUE;
		    }
		    else
          14    	return FALSE;
		}
		
		SV **
     4468046    Perl_av_arylen_p(pTHX_ AV *av) {
		    dVAR;
     4468046        MAGIC *mg = mg_find((SV*)av, PERL_MAGIC_arylen_p);
		
     4468046        if (!mg) {
     4098018    	mg = sv_magicext((SV*)av, 0, PERL_MAGIC_arylen_p, &PL_vtbl_arylen_p,
					 0, 0);
		
     4098018    	if (!mg) {
      ######    	    Perl_die(aTHX_ "panic: av_arylen_p");
			}
			/* sv_magicext won't set this for us because we pass in a NULL obj  */
     4098018    	mg->mg_flags |= MGf_REFCOUNTED;
		    }
     4468046        return &(mg->mg_obj);
		}
		
		/*
		 * Local variables:
		 * c-indentation-style: bsd
		 * c-basic-offset: 4
		 * indent-tabs-mode: t
		 * End:
		 *
		 * ex: set ts=8 sts=4 sw=4 noet:
		 */