[p5sagit/p5-mst-13.2.git] / av.c

/*    av.c
 *
 *    Copyright (c) 1991-1997, Larry Wall
 *
 *    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
 */

#include "EXTERN.h"
#include "perl.h"

static void	av_reify _((AV* av));

static void
av_reify(av)
AV* av;
{
    I32 key;
    SV* sv;
    
    key = AvMAX(av) + 1;
    while (key > AvFILL(av) + 1)
	AvARRAY(av)[--key] = &sv_undef;
    while (key) {
	sv = AvARRAY(av)[--key];
	assert(sv);
	if (sv != &sv_undef) {
	    dTHR;
	    (void)SvREFCNT_inc(sv);
	}
    }
    key = AvARRAY(av) - AvALLOC(av);
    while (key)
	AvALLOC(av)[--key] = &sv_undef;
    AvREAL_on(av);
}

void
av_extend(av,key)
AV *av;
I32 key;
{
    dTHR;			/* only necessary if we have to extend stack */
    if (key > AvMAX(av)) {
	SV** ary;
	I32 tmp;
	I32 newmax;

	if (AvALLOC(av) != AvARRAY(av)) {
	    ary = AvALLOC(av) + AvFILL(av) + 1;
	    tmp = AvARRAY(av) - AvALLOC(av);
	    Move(AvARRAY(av), AvALLOC(av), AvFILL(av)+1, SV*);
	    AvMAX(av) += tmp;
	    SvPVX(av) = (char*)AvALLOC(av);
	    if (AvREAL(av)) {
		while (tmp)
		    ary[--tmp] = &sv_undef;
	    }
	    
	    if (key > AvMAX(av) - 10) {
		newmax = key + AvMAX(av);
		goto resize;
	    }
	}
	else {
	    if (AvALLOC(av)) {
#ifndef STRANGE_MALLOC
		U32 bytes;
#endif

		newmax = key + AvMAX(av) / 5;
	      resize:
#ifdef STRANGE_MALLOC
		Renew(AvALLOC(av),newmax+1, SV*);
#else
		bytes = (newmax + 1) * sizeof(SV*);
#define MALLOC_OVERHEAD 16
		tmp = MALLOC_OVERHEAD;
		while (tmp - MALLOC_OVERHEAD < bytes)
		    tmp += tmp;
		tmp -= MALLOC_OVERHEAD;
		tmp /= sizeof(SV*);
		assert(tmp > newmax);
		newmax = tmp - 1;
		New(2,ary, newmax+1, SV*);
		Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
		if (AvMAX(av) > 64 && !nice_chunk) {
		    nice_chunk = (char*)AvALLOC(av);
		    nice_chunk_size = (AvMAX(av) + 1) * sizeof(SV*);
		}
		else
		    Safefree(AvALLOC(av));
		AvALLOC(av) = ary;
#endif
		ary = AvALLOC(av) + AvMAX(av) + 1;
		tmp = newmax - AvMAX(av);
		if (av == curstack) {	/* Oops, grew stack (via av_store()?) */
		    stack_sp = AvALLOC(av) + (stack_sp - stack_base);
		    stack_base = AvALLOC(av);
		    stack_max = stack_base + newmax;
		}
	    }
	    else {
		newmax = key < 4 ? 4 : key;
		New(2,AvALLOC(av), newmax+1, SV*);
		ary = AvALLOC(av) + 1;
		tmp = newmax;
		AvALLOC(av)[0] = &sv_undef;	/* For the stacks */
	    }
	    if (AvREAL(av)) {
		while (tmp)
		    ary[--tmp] = &sv_undef;
	    }
	    
	    SvPVX(av) = (char*)AvALLOC(av);
	    AvMAX(av) = newmax;
	}
    }
}

SV**
av_fetch(av,key,lval)
register AV *av;
I32 key;
I32 lval;
{
    SV *sv;

    if (!av)
	return 0;

    if (SvRMAGICAL(av)) {
	if (mg_find((SV*)av,'P')) {
	    dTHR;
	    sv = sv_newmortal();
	    mg_copy((SV*)av, sv, 0, key);
	    Sv = sv;
	    return &Sv;
	}
    }

    if (key < 0) {
	key += AvFILL(av) + 1;
	if (key < 0)
	    return 0;
    }
    else if (key > AvFILL(av)) {
	if (!lval)
	    return 0;
	if (AvREALISH(av))
	    sv = NEWSV(5,0);
	else
	    sv = sv_newmortal();
	return av_store(av,key,sv);
    }
    if (AvARRAY(av)[key] == &sv_undef) {
    emptyness:
	if (lval) {
	    sv = NEWSV(6,0);
	    return av_store(av,key,sv);
	}
	return 0;
    }
    else if (AvREIFY(av)
	     && (!AvARRAY(av)[key]	/* eg. @_ could have freed elts */
		 || SvTYPE(AvARRAY(av)[key]) == SVTYPEMASK)) {
	AvARRAY(av)[key] = &sv_undef;	/* 1/2 reify */
	goto emptyness;
    }
    return &AvARRAY(av)[key];
}

SV**
av_store(av,key,val)
register AV *av;
I32 key;
SV *val;
{
    SV** ary;

    if (!av)
	return 0;
    if (!val)
	val = &sv_undef;

    if (SvRMAGICAL(av)) {
	if (mg_find((SV*)av,'P')) {
	    if (val != &sv_undef)
		mg_copy((SV*)av, val, 0, key);
	    return 0;
	}
    }

    if (key < 0) {
	key += AvFILL(av) + 1;
	if (key < 0)
	    return 0;
    }
    if (SvREADONLY(av) && key >= AvFILL(av))
	croak(no_modify);
    if (!AvREAL(av) && AvREIFY(av))
	av_reify(av);
    if (key > AvMAX(av))
	av_extend(av,key);
    ary = AvARRAY(av);
    if (AvFILL(av) < key) {
	if (!AvREAL(av)) {
	    dTHR;
	    if (av == curstack && key > stack_sp - stack_base)
		stack_sp = stack_base + key;	/* XPUSH in disguise */
	    do
		ary[++AvFILL(av)] = &sv_undef;
	    while (AvFILL(av) < key);
	}
	AvFILL(av) = key;
    }
    else if (AvREAL(av))
	SvREFCNT_dec(ary[key]);
    ary[key] = val;
    if (SvSMAGICAL(av)) {
	if (val != &sv_undef) {
	    MAGIC* mg = SvMAGIC(av);
	    sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
	}
	mg_set((SV*)av);
    }
    return &ary[key];
}

AV *
newAV()
{
    register AV *av;

    av = (AV*)NEWSV(3,0);
    sv_upgrade((SV *)av, SVt_PVAV);
    AvREAL_on(av);
    AvALLOC(av) = 0;
    SvPVX(av) = 0;
    AvMAX(av) = AvFILL(av) = -1;
    return av;
}

AV *
av_make(size,strp)
register I32 size;
register SV **strp;
{
    register AV *av;
    register I32 i;
    register SV** ary;

    av = (AV*)NEWSV(8,0);
    sv_upgrade((SV *) av,SVt_PVAV);
    New(4,ary,size+1,SV*);
    AvALLOC(av) = ary;
    AvFLAGS(av) = AVf_REAL;
    SvPVX(av) = (char*)ary;
    AvFILL(av) = size - 1;
    AvMAX(av) = size - 1;
    for (i = 0; i < size; i++) {
	assert (*strp);
	ary[i] = NEWSV(7,0);
	sv_setsv(ary[i], *strp);
	strp++;
    }
    return av;
}

AV *
av_fake(size,strp)
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*);
    AvFLAGS(av) = AVf_REIFY;
    SvPVX(av) = (char*)ary;
    AvFILL(av) = size - 1;
    AvMAX(av) = size - 1;
    while (size--) {
	assert (*strp);
	SvTEMP_off(*strp);
	strp++;
    }
    return av;
}

void
av_clear(av)
register AV *av;
{
    register I32 key;
    SV** ary;

#ifdef DEBUGGING
    if (SvREFCNT(av) <= 0) {
	warn("Attempt to clear deleted array");
    }
#endif
    if (!av || AvMAX(av) < 0)
	return;
    /*SUPPRESS 560*/

    if (AvREAL(av)) {
	ary = AvARRAY(av);
	key = AvFILL(av) + 1;
	while (key) {
	    SvREFCNT_dec(ary[--key]);
	    ary[key] = &sv_undef;
	}
    }
    if (key = AvARRAY(av) - AvALLOC(av)) {
	AvMAX(av) += key;
	SvPVX(av) = (char*)AvALLOC(av);
    }
    AvFILL(av) = -1;
}

void
av_undef(av)
register AV *av;
{
    register I32 key;

    if (!av)
	return;
    /*SUPPRESS 560*/
    if (AvREAL(av)) {
	key = AvFILL(av) + 1;
	while (key)
	    SvREFCNT_dec(AvARRAY(av)[--key]);
    }
    Safefree(AvALLOC(av));
    AvALLOC(av) = 0;
    SvPVX(av) = 0;
    AvMAX(av) = AvFILL(av) = -1;
    if (AvARYLEN(av)) {
	SvREFCNT_dec(AvARYLEN(av));
	AvARYLEN(av) = 0;
    }
}

void
av_push(av,val)
register AV *av;
SV *val;
{
    if (!av)
	return;
    av_store(av,AvFILL(av)+1,val);
}

SV *
av_pop(av)
register AV *av;
{
    SV *retval;

    if (!av || AvFILL(av) < 0)
	return &sv_undef;
    if (SvREADONLY(av))
	croak(no_modify);
    retval = AvARRAY(av)[AvFILL(av)];
    AvARRAY(av)[AvFILL(av)--] = &sv_undef;
    if (SvSMAGICAL(av))
	mg_set((SV*)av);
    return retval;
}

void
av_unshift(av,num)
register AV *av;
register I32 num;
{
    register I32 i;
    register SV **sstr,**dstr;

    if (!av || num <= 0)
	return;
    if (SvREADONLY(av))
	croak(no_modify);
    if (!AvREAL(av) && AvREIFY(av))
	av_reify(av);
    i = AvARRAY(av) - AvALLOC(av);
    if (i) {
	if (i > num)
	    i = num;
	num -= i;
    
	AvMAX(av) += i;
	AvFILL(av) += i;
	SvPVX(av) = (char*)(AvARRAY(av) - i);
    }
    if (num) {
	av_extend(av,AvFILL(av)+num);
	AvFILL(av) += num;
	dstr = AvARRAY(av) + AvFILL(av);
	sstr = dstr - num;
#ifdef BUGGY_MSC5
 # pragma loop_opt(off)	/* don't loop-optimize the following code */
#endif /* BUGGY_MSC5 */
	for (i = AvFILL(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;
    }
}

SV *
av_shift(av)
register AV *av;
{
    SV *retval;

    if (!av || AvFILL(av) < 0)
	return &sv_undef;
    if (SvREADONLY(av))
	croak(no_modify);
    retval = *AvARRAY(av);
    if (AvREAL(av))
	*AvARRAY(av) = &sv_undef;
    SvPVX(av) = (char*)(AvARRAY(av) + 1);
    AvMAX(av)--;
    AvFILL(av)--;
    if (SvSMAGICAL(av))
	mg_set((SV*)av);
    return retval;
}

I32
av_len(av)
register AV *av;
{
    return AvFILL(av);
}

void
av_fill(av, fill)
register AV *av;
I32 fill;
{
    if (!av)
	croak("panic: null array");
    if (fill < 0)
	fill = -1;
    if (fill <= AvMAX(av)) {
	I32 key = AvFILL(av);
	SV** ary = AvARRAY(av);

	if (AvREAL(av)) {
	    while (key > fill) {
		SvREFCNT_dec(ary[key]);
		ary[key--] = &sv_undef;
	    }
	}
	else {
	    while (key < fill)
		ary[++key] = &sv_undef;
	}
	    
	AvFILL(av) = fill;
	if (SvSMAGICAL(av))
	    mg_set((SV*)av);
    }
    else
	(void)av_store(av,fill,&sv_undef);
}

SV**
avhv_fetch(av, key, klen, lval)
AV *av;
char *key;
U32 klen;
I32 lval;
{
    SV **keys, **indsvp;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    indsvp = hv_fetch((HV*)SvRV(*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((HV*)SvRV(*keys), key, klen, newSViv(ind), 0);
    }
    return av_fetch(av, ind, lval);
}

SV**
avhv_fetch_ent(av, keysv, lval, hash)
AV *av;
SV *keysv;
I32 lval;
U32 hash;
{
    SV **keys, **indsvp;
    HE *he;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    he = hv_fetch_ent((HV*)SvRV(*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((HV*)SvRV(*keys), keysv, newSViv(ind), 0);
    }
    return av_fetch(av, ind, lval);
}

SV**
avhv_store(av, key, klen, val, hash)
AV *av;
char *key;
U32 klen;
SV *val;
U32 hash;
{
    SV **keys, **indsvp;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    indsvp = hv_fetch((HV*)SvRV(*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((HV*)SvRV(*keys), key, klen, newSViv(ind), hash);
    }
    return av_store(av, ind, val);
}

SV**
avhv_store_ent(av, keysv, val, hash)
AV *av;
SV *keysv;
SV *val;
U32 hash;
{
    SV **keys;
    HE *he;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    he = hv_fetch_ent((HV*)SvRV(*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((HV*)SvRV(*keys), keysv, newSViv(ind), hash);
    }
    return av_store(av, ind, val);
}

bool
avhv_exists_ent(av, keysv, hash)
AV *av;
SV *keysv;
U32 hash;
{
    SV **keys;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    return hv_exists_ent((HV*)SvRV(*keys), keysv, hash);
}

bool
avhv_exists(av, key, klen)
AV *av;
char *key;
U32 klen;
{
    SV **keys;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    return hv_exists((HV*)SvRV(*keys), key, klen);
}

/* avhv_delete leaks. Caller can re-index and compress if so desired. */
SV *
avhv_delete(av, key, klen, flags)
AV *av;
char *key;
U32 klen;
I32 flags;
{
    SV **keys;
    SV *sv;
    SV **svp;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    sv = hv_delete((HV*)SvRV(*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, keysv, flags, hash)
AV *av;
SV *keysv;
I32 flags;
U32 hash;
{
    SV **keys;
    SV *sv;
    SV **svp;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    sv = hv_delete_ent((HV*)SvRV(*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 *av;
{
    SV **keys;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    return hv_iterinit((HV*)SvRV(*keys));
}

HE *
avhv_iternext(av)
AV *av;
{
    SV **keys;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    return hv_iternext((HV*)SvRV(*keys));
}

SV *
avhv_iterval(av, entry)
AV *av;
register HE *entry;
{
    SV **keys;
    SV *sv;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    sv = hv_iterval((HV*)SvRV(*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, key, retlen)
AV *av;
char **key;
I32 *retlen;
{
    SV **keys;
    HE *he;
    SV *sv;
    I32 ind;
    
    keys = av_fetch(av, 0, FALSE);
    if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
	croak("Can't coerce array into hash");
    if ( (he = hv_iternext((HV*)SvRV(*keys))) == NULL)
        return NULL;
    *key = hv_iterkey(he, retlen);
    sv = hv_iterval((HV*)SvRV(*keys), he);
    ind = SvIV(sv);
    if (ind < 1)
	croak("Bad index while coercing array into hash");
    return *av_fetch(av, ind, TRUE);
}
Commit	Line	Data
a0d0e21e	1	/* av.c
79072805	2	*
9607fc9c	3	* Copyright (c) 1991-1997, Larry Wall
79072805	4	*
	5	* You may distribute under the terms of either the GNU General Public
	6	* License or the Artistic License, as specified in the README file.
	7	*
a0d0e21e	8	*/
	9
	10	/*
	11	* "...for the Entwives desired order, and plenty, and peace (by which they
	12	* meant that things should remain where they had set them)." --Treebeard
79072805	13	*/
	14
	15	#include "EXTERN.h"
	16	#include "perl.h"
	17
a0d0e21e	18	static void av_reify _((AV* av));
	19
	20	static void
	21	av_reify(av)
	22	AV* av;
	23	{
	24	I32 key;
	25	SV* sv;
	26
	27	key = AvMAX(av) + 1;
	28	while (key > AvFILL(av) + 1)
	29	AvARRAY(av)[--key] = &sv_undef;
	30	while (key) {
	31	sv = AvARRAY(av)[--key];
	32	assert(sv);
11343788	33	if (sv != &sv_undef) {
11343788	34	dTHR;
a0d0e21e	35	(void)SvREFCNT_inc(sv);
11343788	36	}
a0d0e21e	37	}
29de640a	38	key = AvARRAY(av) - AvALLOC(av);
	39	while (key)
	40	AvALLOC(av)[--key] = &sv_undef;
a0d0e21e	41	AvREAL_on(av);
	42	}
	43
	44	void
	45	av_extend(av,key)
	46	AV *av;
	47	I32 key;
	48	{
11343788	49	dTHR; /* only necessary if we have to extend stack */
a0d0e21e	50	if (key > AvMAX(av)) {
	51	SV** ary;
	52	I32 tmp;
	53	I32 newmax;
	54
	55	if (AvALLOC(av) != AvARRAY(av)) {
	56	ary = AvALLOC(av) + AvFILL(av) + 1;
	57	tmp = AvARRAY(av) - AvALLOC(av);
	58	Move(AvARRAY(av), AvALLOC(av), AvFILL(av)+1, SV*);
	59	AvMAX(av) += tmp;
	60	SvPVX(av) = (char*)AvALLOC(av);
	61	if (AvREAL(av)) {
	62	while (tmp)
	63	ary[--tmp] = &sv_undef;
	64	}
	65
	66	if (key > AvMAX(av) - 10) {
	67	newmax = key + AvMAX(av);
	68	goto resize;
	69	}
	70	}
	71	else {
	72	if (AvALLOC(av)) {
c07a80fd	73	#ifndef STRANGE_MALLOC
4633a7c4	74	U32 bytes;
c07a80fd	75	#endif
4633a7c4	76
a0d0e21e	77	newmax = key + AvMAX(av) / 5;
a0d0e21e	78	resize:
4633a7c4	79	#ifdef STRANGE_MALLOC
a0d0e21e	80	Renew(AvALLOC(av),newmax+1, SV*);
4633a7c4	81	#else
	82	bytes = (newmax + 1) * sizeof(SV*);
	83	#define MALLOC_OVERHEAD 16
	84	tmp = MALLOC_OVERHEAD;
	85	while (tmp - MALLOC_OVERHEAD < bytes)
	86	tmp += tmp;
	87	tmp -= MALLOC_OVERHEAD;
	88	tmp /= sizeof(SV*);
	89	assert(tmp > newmax);
	90	newmax = tmp - 1;
	91	New(2,ary, newmax+1, SV*);
	92	Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
c07a80fd	93	if (AvMAX(av) > 64 && !nice_chunk) {
	94	nice_chunk = (char*)AvALLOC(av);
	95	nice_chunk_size = (AvMAX(av) + 1) * sizeof(SV*);
	96	}
4633a7c4	97	else
	98	Safefree(AvALLOC(av));
	99	AvALLOC(av) = ary;
	100	#endif
a0d0e21e	101	ary = AvALLOC(av) + AvMAX(av) + 1;
a0d0e21e	102	tmp = newmax - AvMAX(av);
7d55f622	103	if (av == curstack) { /* Oops, grew stack (via av_store()?) */
a0d0e21e	104	stack_sp = AvALLOC(av) + (stack_sp - stack_base);
	105	stack_base = AvALLOC(av);
	106	stack_max = stack_base + newmax;
	107	}
	108	}
	109	else {
	110	newmax = key < 4 ? 4 : key;
	111	New(2,AvALLOC(av), newmax+1, SV*);
	112	ary = AvALLOC(av) + 1;
	113	tmp = newmax;
	114	AvALLOC(av)[0] = &sv_undef; /* For the stacks */
	115	}
	116	if (AvREAL(av)) {
	117	while (tmp)
	118	ary[--tmp] = &sv_undef;
	119	}
	120
	121	SvPVX(av) = (char*)AvALLOC(av);
	122	AvMAX(av) = newmax;
	123	}
	124	}
	125	}
	126
79072805	127	SV**
463ee0b2	128	av_fetch(av,key,lval)
463ee0b2	129	register AV *av;
79072805	130	I32 key;
	131	I32 lval;
	132	{
	133	SV *sv;
	134
a0d0e21e	135	if (!av)
	136	return 0;
	137
8990e307	138	if (SvRMAGICAL(av)) {
463ee0b2	139	if (mg_find((SV*)av,'P')) {
11343788	140	dTHR;
8990e307	141	sv = sv_newmortal();
463ee0b2	142	mg_copy((SV*)av, sv, 0, key);
463ee0b2	143	Sv = sv;
	144	return &Sv;
	145	}
	146	}
	147
a0d0e21e	148	if (key < 0) {
	149	key += AvFILL(av) + 1;
	150	if (key < 0)
	151	return 0;
	152	}
	153	else if (key > AvFILL(av)) {
	154	if (!lval)
	155	return 0;
	156	if (AvREALISH(av))
	157	sv = NEWSV(5,0);
	158	else
	159	sv = sv_newmortal();
	160	return av_store(av,key,sv);
79072805	161	}
a0d0e21e	162	if (AvARRAY(av)[key] == &sv_undef) {
4dbf4341	163	emptyness:
79072805	164	if (lval) {
79072805	165	sv = NEWSV(6,0);
463ee0b2	166	return av_store(av,key,sv);
79072805	167	}
	168	return 0;
	169	}
4dbf4341	170	else if (AvREIFY(av)
	171	&& (!AvARRAY(av)[key] /* eg. @_ could have freed elts */
	172	\|\| SvTYPE(AvARRAY(av)[key]) == SVTYPEMASK)) {
	173	AvARRAY(av)[key] = &sv_undef; /* 1/2 reify */
	174	goto emptyness;
	175	}
463ee0b2	176	return &AvARRAY(av)[key];
79072805	177	}
	178
	179	SV**
463ee0b2	180	av_store(av,key,val)
463ee0b2	181	register AV *av;
79072805	182	I32 key;
	183	SV *val;
	184	{
79072805	185	SV** ary;
79072805	186
a0d0e21e	187	if (!av)
a0d0e21e	188	return 0;
43fcc5d2	189	if (!val)
43fcc5d2	190	val = &sv_undef;
463ee0b2	191
8990e307	192	if (SvRMAGICAL(av)) {
463ee0b2	193	if (mg_find((SV*)av,'P')) {
43fcc5d2	194	if (val != &sv_undef)
43fcc5d2	195	mg_copy((SV*)av, val, 0, key);
463ee0b2	196	return 0;
	197	}
	198	}
	199
a0d0e21e	200	if (key < 0) {
	201	key += AvFILL(av) + 1;
	202	if (key < 0)
	203	return 0;
79072805	204	}
43fcc5d2	205	if (SvREADONLY(av) && key >= AvFILL(av))
43fcc5d2	206	croak(no_modify);
49beac48	207	if (!AvREAL(av) && AvREIFY(av))
a0d0e21e	208	av_reify(av);
a0d0e21e	209	if (key > AvMAX(av))
a0d0e21e	210	av_extend(av,key);
463ee0b2	211	ary = AvARRAY(av);
a0d0e21e	212	if (AvFILL(av) < key) {
a0d0e21e	213	if (!AvREAL(av)) {
11343788	214	dTHR;
7d55f622	215	if (av == curstack && key > stack_sp - stack_base)
a0d0e21e	216	stack_sp = stack_base + key; /* XPUSH in disguise */
	217	do
	218	ary[++AvFILL(av)] = &sv_undef;
	219	while (AvFILL(av) < key);
79072805	220	}
a0d0e21e	221	AvFILL(av) = key;
79072805	222	}
a0d0e21e	223	else if (AvREAL(av))
a0d0e21e	224	SvREFCNT_dec(ary[key]);
79072805	225	ary[key] = val;
8990e307	226	if (SvSMAGICAL(av)) {
a0d0e21e	227	if (val != &sv_undef) {
	228	MAGIC* mg = SvMAGIC(av);
	229	sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
	230	}
463ee0b2	231	mg_set((SV*)av);
463ee0b2	232	}
79072805	233	return &ary[key];
	234	}
	235
	236	AV *
	237	newAV()
	238	{
463ee0b2	239	register AV *av;
79072805	240
a0d0e21e	241	av = (AV*)NEWSV(3,0);
a0d0e21e	242	sv_upgrade((SV *)av, SVt_PVAV);
463ee0b2	243	AvREAL_on(av);
	244	AvALLOC(av) = 0;
	245	SvPVX(av) = 0;
	246	AvMAX(av) = AvFILL(av) = -1;
	247	return av;
79072805	248	}
	249
	250	AV *
	251	av_make(size,strp)
	252	register I32 size;
	253	register SV **strp;
	254	{
463ee0b2	255	register AV *av;
79072805	256	register I32 i;
	257	register SV** ary;
	258
a0d0e21e	259	av = (AV*)NEWSV(8,0);
a0d0e21e	260	sv_upgrade((SV *) av,SVt_PVAV);
79072805	261	New(4,ary,size+1,SV*);
463ee0b2	262	AvALLOC(av) = ary;
a0d0e21e	263	AvFLAGS(av) = AVf_REAL;
463ee0b2	264	SvPVX(av) = (char*)ary;
	265	AvFILL(av) = size - 1;
	266	AvMAX(av) = size - 1;
79072805	267	for (i = 0; i < size; i++) {
a0d0e21e	268	assert (*strp);
	269	ary[i] = NEWSV(7,0);
	270	sv_setsv(ary[i], *strp);
79072805	271	strp++;
79072805	272	}
463ee0b2	273	return av;
79072805	274	}
	275
	276	AV *
	277	av_fake(size,strp)
	278	register I32 size;
	279	register SV **strp;
	280	{
463ee0b2	281	register AV *av;
79072805	282	register SV** ary;
79072805	283
a0d0e21e	284	av = (AV*)NEWSV(9,0);
a0d0e21e	285	sv_upgrade((SV *)av, SVt_PVAV);
79072805	286	New(4,ary,size+1,SV*);
463ee0b2	287	AvALLOC(av) = ary;
79072805	288	Copy(strp,ary,size,SV*);
a0d0e21e	289	AvFLAGS(av) = AVf_REIFY;
463ee0b2	290	SvPVX(av) = (char*)ary;
	291	AvFILL(av) = size - 1;
	292	AvMAX(av) = size - 1;
79072805	293	while (size--) {
a0d0e21e	294	assert (*strp);
a0d0e21e	295	SvTEMP_off(*strp);
79072805	296	strp++;
79072805	297	}
463ee0b2	298	return av;
79072805	299	}
	300
	301	void
463ee0b2	302	av_clear(av)
463ee0b2	303	register AV *av;
79072805	304	{
79072805	305	register I32 key;
a0d0e21e	306	SV** ary;
79072805	307
7d55f622	308	#ifdef DEBUGGING
	309	if (SvREFCNT(av) <= 0) {
	310	warn("Attempt to clear deleted array");
	311	}
	312	#endif
a0d0e21e	313	if (!av \|\| AvMAX(av) < 0)
79072805	314	return;
79072805	315	/SUPPRESS 560/
a0d0e21e	316
	317	if (AvREAL(av)) {
	318	ary = AvARRAY(av);
	319	key = AvFILL(av) + 1;
	320	while (key) {
	321	SvREFCNT_dec(ary[--key]);
	322	ary[key] = &sv_undef;
	323	}
	324	}
463ee0b2	325	if (key = AvARRAY(av) - AvALLOC(av)) {
463ee0b2	326	AvMAX(av) += key;
a0d0e21e	327	SvPVX(av) = (char*)AvALLOC(av);
79072805	328	}
463ee0b2	329	AvFILL(av) = -1;
79072805	330	}
	331
	332	void
463ee0b2	333	av_undef(av)
463ee0b2	334	register AV *av;
79072805	335	{
	336	register I32 key;
	337
463ee0b2	338	if (!av)
79072805	339	return;
79072805	340	/SUPPRESS 560/
a0d0e21e	341	if (AvREAL(av)) {
	342	key = AvFILL(av) + 1;
	343	while (key)
	344	SvREFCNT_dec(AvARRAY(av)[--key]);
	345	}
463ee0b2	346	Safefree(AvALLOC(av));
	347	AvALLOC(av) = 0;
	348	SvPVX(av) = 0;
	349	AvMAX(av) = AvFILL(av) = -1;
748a9306	350	if (AvARYLEN(av)) {
	351	SvREFCNT_dec(AvARYLEN(av));
	352	AvARYLEN(av) = 0;
	353	}
79072805	354	}
79072805	355
a0d0e21e	356	void
463ee0b2	357	av_push(av,val)
463ee0b2	358	register AV *av;
79072805	359	SV *val;
79072805	360	{
a0d0e21e	361	if (!av)
	362	return;
	363	av_store(av,AvFILL(av)+1,val);
79072805	364	}
	365
	366	SV *
463ee0b2	367	av_pop(av)
463ee0b2	368	register AV *av;
79072805	369	{
	370	SV *retval;
	371
a0d0e21e	372	if (!av \|\| AvFILL(av) < 0)
a0d0e21e	373	return &sv_undef;
43fcc5d2	374	if (SvREADONLY(av))
43fcc5d2	375	croak(no_modify);
463ee0b2	376	retval = AvARRAY(av)[AvFILL(av)];
a0d0e21e	377	AvARRAY(av)[AvFILL(av)--] = &sv_undef;
8990e307	378	if (SvSMAGICAL(av))
463ee0b2	379	mg_set((SV*)av);
79072805	380	return retval;
	381	}
	382
	383	void
463ee0b2	384	av_unshift(av,num)
463ee0b2	385	register AV *av;
79072805	386	register I32 num;
	387	{
	388	register I32 i;
	389	register SV sstr,dstr;
	390
a0d0e21e	391	if (!av \|\| num <= 0)
79072805	392	return;
43fcc5d2	393	if (SvREADONLY(av))
43fcc5d2	394	croak(no_modify);
49beac48	395	if (!AvREAL(av) && AvREIFY(av))
49beac48	396	av_reify(av);
a0d0e21e	397	i = AvARRAY(av) - AvALLOC(av);
	398	if (i) {
	399	if (i > num)
	400	i = num;
	401	num -= i;
	402
	403	AvMAX(av) += i;
	404	AvFILL(av) += i;
	405	SvPVX(av) = (char*)(AvARRAY(av) - i);
	406	}
	407	if (num) {
	408	av_extend(av,AvFILL(av)+num);
	409	AvFILL(av) += num;
463ee0b2	410	dstr = AvARRAY(av) + AvFILL(av);
79072805	411	sstr = dstr - num;
	412	#ifdef BUGGY_MSC5
	413	# pragma loop_opt(off) /* don't loop-optimize the following code */
	414	#endif /* BUGGY_MSC5 */
a0d0e21e	415	for (i = AvFILL(av) - num; i >= 0; --i) {
79072805	416	dstr-- = sstr--;
	417	#ifdef BUGGY_MSC5
	418	# pragma loop_opt() /* loop-optimization back to command-line setting */
	419	#endif /* BUGGY_MSC5 */
	420	}
a0d0e21e	421	while (num)
a0d0e21e	422	AvARRAY(av)[--num] = &sv_undef;
79072805	423	}
	424	}
	425
	426	SV *
463ee0b2	427	av_shift(av)
463ee0b2	428	register AV *av;
79072805	429	{
	430	SV *retval;
	431
a0d0e21e	432	if (!av \|\| AvFILL(av) < 0)
a0d0e21e	433	return &sv_undef;
43fcc5d2	434	if (SvREADONLY(av))
43fcc5d2	435	croak(no_modify);
463ee0b2	436	retval = *AvARRAY(av);
a0d0e21e	437	if (AvREAL(av))
a0d0e21e	438	*AvARRAY(av) = &sv_undef;
463ee0b2	439	SvPVX(av) = (char*)(AvARRAY(av) + 1);
	440	AvMAX(av)--;
	441	AvFILL(av)--;
8990e307	442	if (SvSMAGICAL(av))
463ee0b2	443	mg_set((SV*)av);
79072805	444	return retval;
	445	}
	446
	447	I32
463ee0b2	448	av_len(av)
463ee0b2	449	register AV *av;
79072805	450	{
463ee0b2	451	return AvFILL(av);
79072805	452	}
	453
	454	void
463ee0b2	455	av_fill(av, fill)
463ee0b2	456	register AV *av;
79072805	457	I32 fill;
79072805	458	{
a0d0e21e	459	if (!av)
a0d0e21e	460	croak("panic: null array");
79072805	461	if (fill < 0)
79072805	462	fill = -1;
463ee0b2	463	if (fill <= AvMAX(av)) {
a0d0e21e	464	I32 key = AvFILL(av);
	465	SV** ary = AvARRAY(av);
	466
	467	if (AvREAL(av)) {
	468	while (key > fill) {
	469	SvREFCNT_dec(ary[key]);
	470	ary[key--] = &sv_undef;
	471	}
	472	}
	473	else {
	474	while (key < fill)
	475	ary[++key] = &sv_undef;
	476	}
	477
463ee0b2	478	AvFILL(av) = fill;
8990e307	479	if (SvSMAGICAL(av))
463ee0b2	480	mg_set((SV*)av);
463ee0b2	481	}
a0d0e21e	482	else
a0d0e21e	483	(void)av_store(av,fill,&sv_undef);
79072805	484	}
c750a3ec	485
	486	SV**
	487	avhv_fetch(av, key, klen, lval)
	488	AV *av;
	489	char *key;
	490	U32 klen;
	491	I32 lval;
	492	{
	493	SV keys, indsvp;
	494	I32 ind;
	495
	496	keys = av_fetch(av, 0, FALSE);
	497	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	498	croak("Can't coerce array into hash");
	499	indsvp = hv_fetch((HV)SvRV(keys), key, klen, FALSE);
	500	if (indsvp) {
	501	ind = SvIV(*indsvp);
	502	if (ind < 1)
	503	croak("Bad index while coercing array into hash");
	504	} else {
	505	if (!lval)
	506	return 0;
	507
	508	ind = AvFILL(av) + 1;
	509	hv_store((HV)SvRV(keys), key, klen, newSViv(ind), 0);
	510	}
	511	return av_fetch(av, ind, lval);
	512	}
	513
	514	SV**
97fcbf96	515	avhv_fetch_ent(av, keysv, lval, hash)
	516	AV *av;
	517	SV *keysv;
	518	I32 lval;
	519	U32 hash;
	520	{
	521	SV keys, indsvp;
	522	HE *he;
	523	I32 ind;
	524
	525	keys = av_fetch(av, 0, FALSE);
	526	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	527	croak("Can't coerce array into hash");
	528	he = hv_fetch_ent((HV)SvRV(keys), keysv, FALSE, hash);
	529	if (he) {
	530	ind = SvIV(HeVAL(he));
	531	if (ind < 1)
	532	croak("Bad index while coercing array into hash");
	533	} else {
	534	if (!lval)
	535	return 0;
	536
	537	ind = AvFILL(av) + 1;
	538	hv_store_ent((HV)SvRV(keys), keysv, newSViv(ind), 0);
	539	}
	540	return av_fetch(av, ind, lval);
	541	}
	542
	543	SV**
c750a3ec	544	avhv_store(av, key, klen, val, hash)
	545	AV *av;
	546	char *key;
	547	U32 klen;
	548	SV *val;
	549	U32 hash;
	550	{
	551	SV keys, indsvp;
	552	I32 ind;
	553
	554	keys = av_fetch(av, 0, FALSE);
	555	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	556	croak("Can't coerce array into hash");
	557	indsvp = hv_fetch((HV)SvRV(keys), key, klen, FALSE);
	558	if (indsvp) {
	559	ind = SvIV(*indsvp);
	560	if (ind < 1)
	561	croak("Bad index while coercing array into hash");
	562	} else {
	563	ind = AvFILL(av) + 1;
	564	hv_store((HV)SvRV(keys), key, klen, newSViv(ind), hash);
	565	}
	566	return av_store(av, ind, val);
	567	}
	568
5bc6513d	569	SV**
	570	avhv_store_ent(av, keysv, val, hash)
	571	AV *av;
	572	SV *keysv;
	573	SV *val;
	574	U32 hash;
	575	{
	576	SV **keys;
	577	HE *he;
	578	I32 ind;
	579
	580	keys = av_fetch(av, 0, FALSE);
	581	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	582	croak("Can't coerce array into hash");
	583	he = hv_fetch_ent((HV)SvRV(keys), keysv, FALSE, hash);
	584	if (he) {
	585	ind = SvIV(HeVAL(he));
	586	if (ind < 1)
	587	croak("Bad index while coercing array into hash");
	588	} else {
	589	ind = AvFILL(av) + 1;
	590	hv_store_ent((HV)SvRV(keys), keysv, newSViv(ind), hash);
	591	}
	592	return av_store(av, ind, val);
	593	}
	594
c750a3ec	595	bool
97fcbf96	596	avhv_exists_ent(av, keysv, hash)
	597	AV *av;
	598	SV *keysv;
	599	U32 hash;
	600	{
	601	SV **keys;
	602
	603	keys = av_fetch(av, 0, FALSE);
	604	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	605	croak("Can't coerce array into hash");
	606	return hv_exists_ent((HV)SvRV(keys), keysv, hash);
	607	}
	608
	609	bool
c750a3ec	610	avhv_exists(av, key, klen)
	611	AV *av;
	612	char *key;
	613	U32 klen;
	614	{
	615	SV **keys;
	616
	617	keys = av_fetch(av, 0, FALSE);
	618	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	619	croak("Can't coerce array into hash");
	620	return hv_exists((HV)SvRV(keys), key, klen);
	621	}
	622
	623	/* avhv_delete leaks. Caller can re-index and compress if so desired. */
	624	SV *
	625	avhv_delete(av, key, klen, flags)
	626	AV *av;
	627	char *key;
	628	U32 klen;
	629	I32 flags;
	630	{
	631	SV **keys;
	632	SV *sv;
	633	SV **svp;
	634	I32 ind;
	635
	636	keys = av_fetch(av, 0, FALSE);
	637	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	638	croak("Can't coerce array into hash");
	639	sv = hv_delete((HV)SvRV(keys), key, klen, 0);
	640	if (!sv)
	641	return Nullsv;
	642	ind = SvIV(sv);
	643	if (ind < 1)
	644	croak("Bad index while coercing array into hash");
	645	svp = av_fetch(av, ind, FALSE);
	646	if (!svp)
	647	return Nullsv;
	648	if (flags & G_DISCARD) {
	649	sv = Nullsv;
	650	SvREFCNT_dec(*svp);
	651	} else {
	652	sv = sv_2mortal(*svp);
	653	}
	654	*svp = &sv_undef;
	655	return sv;
	656	}
	657
97fcbf96	658	/* avhv_delete_ent leaks. Caller can re-index and compress if so desired. */
	659	SV *
	660	avhv_delete_ent(av, keysv, flags, hash)
	661	AV *av;
	662	SV *keysv;
	663	I32 flags;
	664	U32 hash;
	665	{
	666	SV **keys;
	667	SV *sv;
	668	SV **svp;
	669	I32 ind;
	670
	671	keys = av_fetch(av, 0, FALSE);
	672	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	673	croak("Can't coerce array into hash");
	674	sv = hv_delete_ent((HV)SvRV(keys), keysv, 0, hash);
	675	if (!sv)
	676	return Nullsv;
	677	ind = SvIV(sv);
	678	if (ind < 1)
	679	croak("Bad index while coercing array into hash");
	680	svp = av_fetch(av, ind, FALSE);
	681	if (!svp)
	682	return Nullsv;
	683	if (flags & G_DISCARD) {
	684	sv = Nullsv;
	685	SvREFCNT_dec(*svp);
	686	} else {
	687	sv = sv_2mortal(*svp);
	688	}
	689	*svp = &sv_undef;
	690	return sv;
	691	}
	692
c750a3ec	693	I32
	694	avhv_iterinit(av)
	695	AV *av;
	696	{
	697	SV **keys;
	698
	699	keys = av_fetch(av, 0, FALSE);
	700	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	701	croak("Can't coerce array into hash");
	702	return hv_iterinit((HV)SvRV(keys));
	703	}
	704
	705	HE *
	706	avhv_iternext(av)
	707	AV *av;
	708	{
	709	SV **keys;
	710
	711	keys = av_fetch(av, 0, FALSE);
	712	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	713	croak("Can't coerce array into hash");
	714	return hv_iternext((HV)SvRV(keys));
	715	}
	716
	717	SV *
	718	avhv_iterval(av, entry)
	719	AV *av;
	720	register HE *entry;
	721	{
	722	SV **keys;
	723	SV *sv;
	724	I32 ind;
	725
	726	keys = av_fetch(av, 0, FALSE);
	727	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	728	croak("Can't coerce array into hash");
	729	sv = hv_iterval((HV)SvRV(keys), entry);
	730	ind = SvIV(sv);
	731	if (ind < 1)
	732	croak("Bad index while coercing array into hash");
	733	return *av_fetch(av, ind, TRUE);
	734	}
	735
	736	SV *
	737	avhv_iternextsv(av, key, retlen)
	738	AV *av;
	739	char **key;
	740	I32 *retlen;
	741	{
	742	SV **keys;
	743	HE *he;
	744	SV *sv;
	745	I32 ind;
	746
	747	keys = av_fetch(av, 0, FALSE);
	748	if (!keys \|\| !SvROK(keys) \|\| SvTYPE(SvRV(keys)) != SVt_PVHV)
	749	croak("Can't coerce array into hash");
	750	if ( (he = hv_iternext((HV)SvRV(keys))) == NULL)
	751	return NULL;
	752	*key = hv_iterkey(he, retlen);
	753	sv = hv_iterval((HV)SvRV(keys), he);
	754	ind = SvIV(sv);
	755	if (ind < 1)
	756	croak("Bad index while coercing array into hash");
757	return *av_fetch(av, ind, TRUE);
758	}