[perl5.git] / av.c

/*    av.c
 *
 *    Copyright (c) 1991-1994, 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)
	    (void)SvREFCNT_inc(sv);
    }
    AvREAL_on(av);
}

void
av_extend(av,key)
AV *av;
I32 key;
{
    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')) {
	    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 (SvRMAGICAL(av)) {
	if (mg_find((SV*)av,'P')) {
	    mg_copy((SV*)av, val, 0, key);
	    return 0;
	}
    }

    if (key < 0) {
	key += AvFILL(av) + 1;
	if (key < 0)
	    return 0;
    }
    if (!val)
	val = &sv_undef;

    if (key > AvMAX(av))
	av_extend(av,key);
    if (AvREIFY(av))
	av_reify(av);

    ary = AvARRAY(av);
    if (AvFILL(av) < key) {
	if (!AvREAL(av)) {
	    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;
    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 (!AvREAL(av)) {
	if (AvREIFY(av))
	    av_reify(av);
	else
	    croak("Can't unshift");
    }
    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;
    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);
}
Commit	Line	Data
a0d0e21e	1	/* av.c
79072805	2	*
a0d0e21e	3	* Copyright (c) 1991-1994, Larry Wall
79072805 LW	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 LW	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 LW	13	*/
	14
	15	#include "EXTERN.h"
	16	#include "perl.h"
	17
a0d0e21e LW	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);
	33	if (sv != &sv_undef)
	34	(void)SvREFCNT_inc(sv);
	35	}
	36	AvREAL_on(av);
	37	}
	38
	39	void
	40	av_extend(av,key)
	41	AV *av;
	42	I32 key;
	43	{
	44	if (key > AvMAX(av)) {
	45	SV** ary;
	46	I32 tmp;
	47	I32 newmax;
	48
	49	if (AvALLOC(av) != AvARRAY(av)) {
	50	ary = AvALLOC(av) + AvFILL(av) + 1;
	51	tmp = AvARRAY(av) - AvALLOC(av);
	52	Move(AvARRAY(av), AvALLOC(av), AvFILL(av)+1, SV*);
	53	AvMAX(av) += tmp;
	54	SvPVX(av) = (char*)AvALLOC(av);
	55	if (AvREAL(av)) {
	56	while (tmp)
	57	ary[--tmp] = &sv_undef;
	58	}
	59
	60	if (key > AvMAX(av) - 10) {
	61	newmax = key + AvMAX(av);
	62	goto resize;
	63	}
	64	}
	65	else {
	66	if (AvALLOC(av)) {
c07a80fd	67	#ifndef STRANGE_MALLOC
4633a7c4	68	U32 bytes;
c07a80fd	69	#endif
4633a7c4	70
a0d0e21e LW	71	newmax = key + AvMAX(av) / 5;
a0d0e21e LW	72	resize:
4633a7c4	73	#ifdef STRANGE_MALLOC
a0d0e21e	74	Renew(AvALLOC(av),newmax+1, SV*);
4633a7c4 LW	75	#else
	76	bytes = (newmax + 1) * sizeof(SV*);
	77	#define MALLOC_OVERHEAD 16
	78	tmp = MALLOC_OVERHEAD;
	79	while (tmp - MALLOC_OVERHEAD < bytes)
	80	tmp += tmp;
	81	tmp -= MALLOC_OVERHEAD;
	82	tmp /= sizeof(SV*);
	83	assert(tmp > newmax);
	84	newmax = tmp - 1;
	85	New(2,ary, newmax+1, SV*);
	86	Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
c07a80fd	87	if (AvMAX(av) > 64 && !nice_chunk) {
	88	nice_chunk = (char*)AvALLOC(av);
	89	nice_chunk_size = (AvMAX(av) + 1) * sizeof(SV*);
	90	}
4633a7c4 LW	91	else
	92	Safefree(AvALLOC(av));
	93	AvALLOC(av) = ary;
	94	#endif
a0d0e21e LW	95	ary = AvALLOC(av) + AvMAX(av) + 1;
a0d0e21e LW	96	tmp = newmax - AvMAX(av);
7d55f622	97	if (av == curstack) { /* Oops, grew stack (via av_store()?) */
a0d0e21e LW	98	stack_sp = AvALLOC(av) + (stack_sp - stack_base);
	99	stack_base = AvALLOC(av);
	100	stack_max = stack_base + newmax;
	101	}
	102	}
	103	else {
	104	newmax = key < 4 ? 4 : key;
	105	New(2,AvALLOC(av), newmax+1, SV*);
	106	ary = AvALLOC(av) + 1;
	107	tmp = newmax;
	108	AvALLOC(av)[0] = &sv_undef; /* For the stacks */
	109	}
	110	if (AvREAL(av)) {
	111	while (tmp)
	112	ary[--tmp] = &sv_undef;
	113	}
	114
	115	SvPVX(av) = (char*)AvALLOC(av);
	116	AvMAX(av) = newmax;
	117	}
	118	}
	119	}
	120
79072805	121	SV**
463ee0b2 LW	122	av_fetch(av,key,lval)
463ee0b2 LW	123	register AV *av;
79072805 LW	124	I32 key;
	125	I32 lval;
	126	{
	127	SV *sv;
	128
a0d0e21e LW	129	if (!av)
	130	return 0;
	131
8990e307	132	if (SvRMAGICAL(av)) {
463ee0b2	133	if (mg_find((SV*)av,'P')) {
8990e307	134	sv = sv_newmortal();
463ee0b2	135	mg_copy((SV*)av, sv, 0, key);
463ee0b2 LW	136	Sv = sv;
	137	return &Sv;
	138	}
	139	}
	140
a0d0e21e LW	141	if (key < 0) {
	142	key += AvFILL(av) + 1;
	143	if (key < 0)
	144	return 0;
	145	}
	146	else if (key > AvFILL(av)) {
	147	if (!lval)
	148	return 0;
	149	if (AvREALISH(av))
	150	sv = NEWSV(5,0);
	151	else
	152	sv = sv_newmortal();
	153	return av_store(av,key,sv);
79072805	154	}
a0d0e21e	155	if (AvARRAY(av)[key] == &sv_undef) {
4dbf4341	156	emptyness:
79072805 LW	157	if (lval) {
79072805 LW	158	sv = NEWSV(6,0);
463ee0b2	159	return av_store(av,key,sv);
79072805 LW	160	}
	161	return 0;
	162	}
4dbf4341	163	else if (AvREIFY(av)
	164	&& (!AvARRAY(av)[key] /* eg. @_ could have freed elts */
	165	\|\| SvTYPE(AvARRAY(av)[key]) == SVTYPEMASK)) {
	166	AvARRAY(av)[key] = &sv_undef; /* 1/2 reify */
	167	goto emptyness;
	168	}
463ee0b2	169	return &AvARRAY(av)[key];
79072805 LW	170	}
	171
	172	SV**
463ee0b2 LW	173	av_store(av,key,val)
463ee0b2 LW	174	register AV *av;
79072805 LW	175	I32 key;
	176	SV *val;
	177	{
79072805 LW	178	SV** ary;
79072805 LW	179
a0d0e21e LW	180	if (!av)
a0d0e21e LW	181	return 0;
463ee0b2	182
8990e307	183	if (SvRMAGICAL(av)) {
463ee0b2 LW	184	if (mg_find((SV*)av,'P')) {
	185	mg_copy((SV*)av, val, 0, key);
	186	return 0;
	187	}
	188	}
	189
a0d0e21e LW	190	if (key < 0) {
	191	key += AvFILL(av) + 1;
	192	if (key < 0)
	193	return 0;
79072805	194	}
a0d0e21e LW	195	if (!val)
	196	val = &sv_undef;
	197
	198	if (key > AvMAX(av))
	199	av_extend(av,key);
	200	if (AvREIFY(av))
	201	av_reify(av);
	202
463ee0b2	203	ary = AvARRAY(av);
a0d0e21e LW	204	if (AvFILL(av) < key) {
a0d0e21e LW	205	if (!AvREAL(av)) {
7d55f622	206	if (av == curstack && key > stack_sp - stack_base)
a0d0e21e LW	207	stack_sp = stack_base + key; /* XPUSH in disguise */
	208	do
	209	ary[++AvFILL(av)] = &sv_undef;
	210	while (AvFILL(av) < key);
79072805	211	}
a0d0e21e	212	AvFILL(av) = key;
79072805	213	}
a0d0e21e LW	214	else if (AvREAL(av))
a0d0e21e LW	215	SvREFCNT_dec(ary[key]);
79072805	216	ary[key] = val;
8990e307	217	if (SvSMAGICAL(av)) {
a0d0e21e LW	218	if (val != &sv_undef) {
	219	MAGIC* mg = SvMAGIC(av);
	220	sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
	221	}
463ee0b2 LW	222	mg_set((SV*)av);
463ee0b2 LW	223	}
79072805 LW	224	return &ary[key];
	225	}
	226
	227	AV *
	228	newAV()
	229	{
463ee0b2	230	register AV *av;
79072805	231
a0d0e21e LW	232	av = (AV*)NEWSV(3,0);
a0d0e21e LW	233	sv_upgrade((SV *)av, SVt_PVAV);
463ee0b2 LW	234	AvREAL_on(av);
	235	AvALLOC(av) = 0;
	236	SvPVX(av) = 0;
	237	AvMAX(av) = AvFILL(av) = -1;
	238	return av;
79072805 LW	239	}
	240
	241	AV *
	242	av_make(size,strp)
	243	register I32 size;
	244	register SV **strp;
	245	{
463ee0b2	246	register AV *av;
79072805 LW	247	register I32 i;
	248	register SV** ary;
	249
a0d0e21e LW	250	av = (AV*)NEWSV(8,0);
a0d0e21e LW	251	sv_upgrade((SV *) av,SVt_PVAV);
79072805	252	New(4,ary,size+1,SV*);
463ee0b2	253	AvALLOC(av) = ary;
a0d0e21e	254	AvFLAGS(av) = AVf_REAL;
463ee0b2 LW	255	SvPVX(av) = (char*)ary;
	256	AvFILL(av) = size - 1;
	257	AvMAX(av) = size - 1;
79072805	258	for (i = 0; i < size; i++) {
a0d0e21e LW	259	assert (*strp);
	260	ary[i] = NEWSV(7,0);
	261	sv_setsv(ary[i], *strp);
79072805 LW	262	strp++;
79072805 LW	263	}
463ee0b2	264	return av;
79072805 LW	265	}
	266
	267	AV *
	268	av_fake(size,strp)
	269	register I32 size;
	270	register SV **strp;
	271	{
463ee0b2	272	register AV *av;
79072805 LW	273	register SV** ary;
79072805 LW	274
a0d0e21e LW	275	av = (AV*)NEWSV(9,0);
a0d0e21e LW	276	sv_upgrade((SV *)av, SVt_PVAV);
79072805	277	New(4,ary,size+1,SV*);
463ee0b2	278	AvALLOC(av) = ary;
79072805	279	Copy(strp,ary,size,SV*);
a0d0e21e	280	AvFLAGS(av) = AVf_REIFY;
463ee0b2 LW	281	SvPVX(av) = (char*)ary;
	282	AvFILL(av) = size - 1;
	283	AvMAX(av) = size - 1;
79072805	284	while (size--) {
a0d0e21e LW	285	assert (*strp);
a0d0e21e LW	286	SvTEMP_off(*strp);
79072805 LW	287	strp++;
79072805 LW	288	}
463ee0b2	289	return av;
79072805 LW	290	}
	291
	292	void
463ee0b2 LW	293	av_clear(av)
463ee0b2 LW	294	register AV *av;
79072805 LW	295	{
79072805 LW	296	register I32 key;
a0d0e21e	297	SV** ary;
79072805	298
7d55f622	299	#ifdef DEBUGGING
	300	if (SvREFCNT(av) <= 0) {
	301	warn("Attempt to clear deleted array");
	302	}
	303	#endif
a0d0e21e	304	if (!av \|\| AvMAX(av) < 0)
79072805 LW	305	return;
79072805 LW	306	/SUPPRESS 560/
a0d0e21e LW	307
	308	if (AvREAL(av)) {
	309	ary = AvARRAY(av);
	310	key = AvFILL(av) + 1;
	311	while (key) {
	312	SvREFCNT_dec(ary[--key]);
	313	ary[key] = &sv_undef;
	314	}
	315	}
463ee0b2 LW	316	if (key = AvARRAY(av) - AvALLOC(av)) {
463ee0b2 LW	317	AvMAX(av) += key;
a0d0e21e	318	SvPVX(av) = (char*)AvALLOC(av);
79072805	319	}
463ee0b2	320	AvFILL(av) = -1;
79072805 LW	321	}
	322
	323	void
463ee0b2 LW	324	av_undef(av)
463ee0b2 LW	325	register AV *av;
79072805 LW	326	{
	327	register I32 key;
	328
463ee0b2	329	if (!av)
79072805 LW	330	return;
79072805 LW	331	/SUPPRESS 560/
a0d0e21e LW	332	if (AvREAL(av)) {
	333	key = AvFILL(av) + 1;
	334	while (key)
	335	SvREFCNT_dec(AvARRAY(av)[--key]);
	336	}
463ee0b2 LW	337	Safefree(AvALLOC(av));
	338	AvALLOC(av) = 0;
	339	SvPVX(av) = 0;
	340	AvMAX(av) = AvFILL(av) = -1;
748a9306 LW	341	if (AvARYLEN(av)) {
	342	SvREFCNT_dec(AvARYLEN(av));
	343	AvARYLEN(av) = 0;
	344	}
79072805 LW	345	}
79072805 LW	346
a0d0e21e	347	void
463ee0b2 LW	348	av_push(av,val)
463ee0b2 LW	349	register AV *av;
79072805 LW	350	SV *val;
79072805 LW	351	{
a0d0e21e LW	352	if (!av)
	353	return;
	354	av_store(av,AvFILL(av)+1,val);
79072805 LW	355	}
	356
	357	SV *
463ee0b2 LW	358	av_pop(av)
463ee0b2 LW	359	register AV *av;
79072805 LW	360	{
	361	SV *retval;
	362
a0d0e21e LW	363	if (!av \|\| AvFILL(av) < 0)
a0d0e21e LW	364	return &sv_undef;
463ee0b2	365	retval = AvARRAY(av)[AvFILL(av)];
a0d0e21e	366	AvARRAY(av)[AvFILL(av)--] = &sv_undef;
8990e307	367	if (SvSMAGICAL(av))
463ee0b2	368	mg_set((SV*)av);
79072805 LW	369	return retval;
	370	}
	371
	372	void
463ee0b2 LW	373	av_unshift(av,num)
463ee0b2 LW	374	register AV *av;
79072805 LW	375	register I32 num;
	376	{
	377	register I32 i;
	378	register SV sstr,dstr;
	379
a0d0e21e	380	if (!av \|\| num <= 0)
79072805	381	return;
a0d0e21e LW	382	if (!AvREAL(av)) {
	383	if (AvREIFY(av))
	384	av_reify(av);
	385	else
	386	croak("Can't unshift");
79072805	387	}
a0d0e21e LW	388	i = AvARRAY(av) - AvALLOC(av);
	389	if (i) {
	390	if (i > num)
	391	i = num;
	392	num -= i;
	393
	394	AvMAX(av) += i;
	395	AvFILL(av) += i;
	396	SvPVX(av) = (char*)(AvARRAY(av) - i);
	397	}
	398	if (num) {
	399	av_extend(av,AvFILL(av)+num);
	400	AvFILL(av) += num;
463ee0b2	401	dstr = AvARRAY(av) + AvFILL(av);
79072805 LW	402	sstr = dstr - num;
	403	#ifdef BUGGY_MSC5
	404	# pragma loop_opt(off) /* don't loop-optimize the following code */
	405	#endif /* BUGGY_MSC5 */
a0d0e21e	406	for (i = AvFILL(av) - num; i >= 0; --i) {
79072805 LW	407	dstr-- = sstr--;
	408	#ifdef BUGGY_MSC5
	409	# pragma loop_opt() /* loop-optimization back to command-line setting */
	410	#endif /* BUGGY_MSC5 */
	411	}
a0d0e21e LW	412	while (num)
a0d0e21e LW	413	AvARRAY(av)[--num] = &sv_undef;
79072805 LW	414	}
	415	}
	416
	417	SV *
463ee0b2 LW	418	av_shift(av)
463ee0b2 LW	419	register AV *av;
79072805 LW	420	{
	421	SV *retval;
	422
a0d0e21e LW	423	if (!av \|\| AvFILL(av) < 0)
a0d0e21e LW	424	return &sv_undef;
463ee0b2	425	retval = *AvARRAY(av);
a0d0e21e LW	426	if (AvREAL(av))
a0d0e21e LW	427	*AvARRAY(av) = &sv_undef;
463ee0b2 LW	428	SvPVX(av) = (char*)(AvARRAY(av) + 1);
	429	AvMAX(av)--;
	430	AvFILL(av)--;
8990e307	431	if (SvSMAGICAL(av))
463ee0b2	432	mg_set((SV*)av);
79072805 LW	433	return retval;
	434	}
	435
	436	I32
463ee0b2 LW	437	av_len(av)
463ee0b2 LW	438	register AV *av;
79072805	439	{
463ee0b2	440	return AvFILL(av);
79072805 LW	441	}
	442
	443	void
463ee0b2 LW	444	av_fill(av, fill)
463ee0b2 LW	445	register AV *av;
79072805 LW	446	I32 fill;
79072805 LW	447	{
a0d0e21e LW	448	if (!av)
a0d0e21e LW	449	croak("panic: null array");
79072805 LW	450	if (fill < 0)
79072805 LW	451	fill = -1;
463ee0b2	452	if (fill <= AvMAX(av)) {
a0d0e21e LW	453	I32 key = AvFILL(av);
	454	SV** ary = AvARRAY(av);
	455
	456	if (AvREAL(av)) {
	457	while (key > fill) {
	458	SvREFCNT_dec(ary[key]);
	459	ary[key--] = &sv_undef;
	460	}
	461	}
	462	else {
	463	while (key < fill)
	464	ary[++key] = &sv_undef;
	465	}
	466
463ee0b2	467	AvFILL(av) = fill;
8990e307	468	if (SvSMAGICAL(av))
463ee0b2 LW	469	mg_set((SV*)av);
463ee0b2 LW	470	}
a0d0e21e LW	471	else
a0d0e21e LW	472	(void)av_store(av,fill,&sv_undef);
79072805	473	}