[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"

void
av_reify(AV *av)
{
    I32 key;
    SV* sv;

    if (AvREAL(av))
	return;
    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 *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)
		    offer_nice_chunk(AvALLOC(av), (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(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(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(void)
{
    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(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);
    AvFLAGS(av) = AVf_REAL;
    if (size) {		/* `defined' was returning undef for size==0 anyway. */
	New(4,ary,size,SV*);
	AvALLOC(av) = ary;
	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(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(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;

    if (SvRMAGICAL(av))
	mg_clear((SV*)av); 
}

void
av_undef(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(register AV *av, SV *val)
{
    if (!av)
	return;
    av_store(av,AvFILL(av)+1,val);
}

SV *
av_pop(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(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(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(register AV *av)
{
    return AvFILL(av);
}

void
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);
}

  
HV*
avhv_keys(AV *av)
{
    SV **keysp;
    HV *keys = Nullhv;

    keysp = av_fetch(av, 0, FALSE);
    if (keysp) {
	if (SvGMAGICAL(*keysp))
	    mg_get(*keysp);
	if (SvROK(*keysp)) {
	    SV *hash = SvRV(*keysp);
	    if (SvTYPE(hash) == SVt_PVHV)
		keys = (HV*)hash;
	}
    }
    if (!keys)
	croak("Can't coerce array into hash");
    return keys;
}

SV**
avhv_fetch(AV *av, char *key, U32 klen, I32 lval)
{
    SV **indsvp;
    HV *keys = avhv_keys(av);
    I32 ind;
    
    indsvp = hv_fetch(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(keys, key, klen, newSViv(ind), 0);
    }
    return av_fetch(av, ind, lval);
}

SV**
avhv_fetch_ent(AV *av, SV *keysv, I32 lval, U32 hash)
{
    SV **indsvp;
    HV *keys = avhv_keys(av);
    HE *he;
    I32 ind;
    
    he = hv_fetch_ent(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(keys, keysv, newSViv(ind), 0);
    }
    return av_fetch(av, ind, lval);
}

SV**
avhv_store(AV *av, char *key, U32 klen, SV *val, U32 hash)
{
    SV **indsvp;
    HV *keys = avhv_keys(av);
    I32 ind;
    
    indsvp = hv_fetch(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(keys, key, klen, newSViv(ind), hash);
    }
    return av_store(av, ind, val);
}

SV**
avhv_store_ent(AV *av, SV *keysv, SV *val, U32 hash)
{
    HV *keys = avhv_keys(av);
    HE *he;
    I32 ind;
    
    he = hv_fetch_ent(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(keys, keysv, newSViv(ind), hash);
    }
    return av_store(av, ind, val);
}

bool
avhv_exists_ent(AV *av, SV *keysv, U32 hash)
{
    HV *keys = avhv_keys(av);
    return hv_exists_ent(keys, keysv, hash);
}

bool
avhv_exists(AV *av, char *key, U32 klen)
{
    HV *keys = avhv_keys(av);
    return hv_exists(keys, key, klen);
}

/* avhv_delete leaks. Caller can re-index and compress if so desired. */
SV *
avhv_delete(AV *av, char *key, U32 klen, I32 flags)
{
    HV *keys = avhv_keys(av);
    SV *sv;
    SV **svp;
    I32 ind;
    
    sv = hv_delete(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 *av, SV *keysv, I32 flags, U32 hash)
{
    HV *keys = avhv_keys(av);
    SV *sv;
    SV **svp;
    I32 ind;
    
    sv = hv_delete_ent(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)
{
    HV *keys = avhv_keys(av);
    return hv_iterinit(keys);
}

HE *
avhv_iternext(AV *av)
{
    HV *keys = avhv_keys(av);
    return hv_iternext(keys);
}

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