[p5sagit/p5-mst-13.2.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)) {
		newmax = key + AvMAX(av) / 5;
	      resize:
		Renew(AvALLOC(av),newmax+1, SV*);
		ary = AvALLOC(av) + AvMAX(av) + 1;
		tmp = newmax - AvMAX(av);
		if (av == stack) {	/* 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) {
	if (lval) {
	    sv = NEWSV(6,0);
	    return av_store(av,key,sv);
	}
	return 0;
    }
    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 == stack && 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;

    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]);
    }
    if (key = AvARRAY(av) - AvALLOC(av)) {
	AvMAX(av) += key;
	SvPVX(av) = (char*)AvALLOC(av);
    }
    Safefree(AvALLOC(av));
    AvALLOC(av) = 0;
    SvPVX(av) = 0;
    AvMAX(av) = AvFILL(av) = -1;
}

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