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

/* $RCSfile: array.c,v $$Revision: 4.1 $$Date: 92/08/07 17:18:22 $
 *
 *    Copyright (c) 1991, 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.
 *
 * $Log:	array.c,v $
 * Revision 4.1  92/08/07  17:18:22  lwall
 * Stage 6 Snapshot
 * 
 * Revision 4.0.1.3  92/06/08  11:45:05  lwall
 * patch20: Perl now distinguishes overlapped copies from non-overlapped
 * 
 * Revision 4.0.1.2  91/11/05  16:00:14  lwall
 * patch11: random cleanup
 * patch11: passing non-existend array elements to subrouting caused core dump
 * 
 * Revision 4.0.1.1  91/06/07  10:19:08  lwall
 * patch4: new copyright notice
 * 
 * Revision 4.0  91/03/20  01:03:32  lwall
 * 4.0 baseline.
 * 
 */

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

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

    if (SvMAGICAL(av)) {
	if (mg_find((SV*)av,'P')) {
	    if (key < 0)
		return 0;
	    sv = sv_2mortal(NEWSV(61,0));
	    mg_copy((SV*)av, sv, 0, key);
	    if (!lval) {
		mg_get((SV*)sv);
		sv_unmagic(sv,'p');
	    }
	    Sv = sv;
	    return &Sv;
	}
    }

    if (key < 0 || key > AvFILL(av)) {
	if (key < 0) {
	    key += AvFILL(av) + 1;
	    if (key < 0)
		return 0;
	}
	else {
	    if (!lval)
		return 0;
	    if (AvREAL(av))
		sv = NEWSV(5,0);
	    else
		sv = sv_mortalcopy(&sv_undef);
	    return av_store(av,key,sv);
	}
    }
    if (!AvARRAY(av)[key]) {
	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;
{
    I32 tmp;
    SV** ary;

    if (key < 0) {
	key += AvFILL(av) + 1;
	if (key < 0)
	    return 0;
    }

    if (SvMAGICAL(av)) {
	if (mg_find((SV*)av,'P')) {
	    mg_copy((SV*)av, val, 0, key);
	    return 0;
	}
    }

    if (key > AvMAX(av)) {
	I32 newmax;

	if (AvALLOC(av) != AvARRAY(av)) {
	    tmp = AvARRAY(av) - AvALLOC(av);
	    Move(AvARRAY(av), AvALLOC(av), AvMAX(av)+1, SV*);
	    Zero(AvALLOC(av)+AvMAX(av)+1, tmp, SV*);
	    AvMAX(av) += tmp;
	    SvPVX(av) = (char*)(AvARRAY(av) - tmp);
	    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*);
		Zero(&AvALLOC(av)[AvMAX(av)+1], newmax - AvMAX(av), SV*);
	    }
	    else {
		newmax = key < 4 ? 4 : key;
		Newz(2,AvALLOC(av), newmax+1, SV*);
	    }
	    SvPVX(av) = (char*)AvALLOC(av);
	    AvMAX(av) = newmax;
	}
    }
    ary = AvARRAY(av);
    if (AvREAL(av)) {
	if (AvFILL(av) < key) {
	    while (++AvFILL(av) < key) {
		if (ary[AvFILL(av)] != Nullsv) {
		    sv_free(ary[AvFILL(av)]);
		    ary[AvFILL(av)] = Nullsv;
		}
	    }
	}
	if (ary[key])
	    sv_free(ary[key]);
    }
    ary[key] = val;
    if (SvMAGICAL(av)) {
	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;

    Newz(1,av,1,AV);
    SvREFCNT(av) = 1;
    sv_upgrade(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;

    Newz(3,av,1,AV);
    sv_upgrade(av,SVt_PVAV);
    New(4,ary,size+1,SV*);
    AvALLOC(av) = ary;
    Zero(ary,size,SV*);
    AvREAL_on(av);
    SvPVX(av) = (char*)ary;
    AvFILL(av) = size - 1;
    AvMAX(av) = size - 1;
    for (i = 0; i < size; i++) {
	if (*strp) {
	    ary[i] = NEWSV(7,0);
	    sv_setsv(ary[i], *strp);
	}
	strp++;
    }
    SvOK_on(av);
    return av;
}

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

    Newz(3,av,1,AV);
    SvREFCNT(av) = 1;
    sv_upgrade(av,SVt_PVAV);
    New(4,ary,size+1,SV*);
    AvALLOC(av) = ary;
    Copy(strp,ary,size,SV*);
    AvREAL_off(av);
    SvPVX(av) = (char*)ary;
    AvFILL(av) = size - 1;
    AvMAX(av) = size - 1;
    while (size--) {
	if (*strp)
	    SvTEMP_off(*strp);
	strp++;
    }
    SvOK_on(av);
    return av;
}

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

    if (!av || !AvREAL(av) || AvMAX(av) < 0)
	return;
    /*SUPPRESS 560*/
    if (key = AvARRAY(av) - AvALLOC(av)) {
	AvMAX(av) += key;
	SvPVX(av) = (char*)(AvARRAY(av) - key);
    }
    for (key = 0; key <= AvMAX(av); key++)
	sv_free(AvARRAY(av)[key]);
    AvFILL(av) = -1;
    Zero(AvARRAY(av), AvMAX(av)+1, SV*);
}

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

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

void
av_free(av)
AV *av;
{
    av_undef(av);
    Safefree(av);
}

bool
av_push(av,val)
register AV *av;
SV *val;
{
    return av_store(av,++(AvFILL(av)),val) != 0;
}

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

    if (AvFILL(av) < 0)
	return Nullsv;
    retval = AvARRAY(av)[AvFILL(av)];
    AvARRAY(av)[AvFILL(av)--] = Nullsv;
    if (SvMAGICAL(av))
	mg_set((SV*)av);
    return retval;
}

void
av_popnulls(av)
register AV *av;
{
    register I32 fill = AvFILL(av);

    while (fill >= 0 && !AvARRAY(av)[fill])
	fill--;
    AvFILL(av) = fill;
}

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

    if (num <= 0)
	return;
    if (AvARRAY(av) - AvALLOC(av) >= num) {
	AvMAX(av) += num;
	AvFILL(av) += num;
	while (num--) {
	    SvPVX(av) = (char*)(AvARRAY(av) - 1);
	    *AvARRAY(av) = Nullsv;
	}
    }
    else {
	(void)av_store(av,AvFILL(av)+num,(SV*)0);	/* maybe extend array */
	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 */
	}
	Zero(AvARRAY(av), num, SV*);
    }
}

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

    if (AvFILL(av) < 0)
	return Nullsv;
    retval = *AvARRAY(av);
    *AvARRAY(av) = Nullsv;
    SvPVX(av) = (char*)(AvARRAY(av) + 1);
    AvMAX(av)--;
    AvFILL(av)--;
    if (SvMAGICAL(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 (fill < 0)
	fill = -1;
    if (fill <= AvMAX(av)) {
	AvFILL(av) = fill;
	if (SvMAGICAL(av))
	    mg_set((SV*)av);
    }
    else {
	AvFILL(av) = fill - 1;		/* don't clobber in-between values */
	(void)av_store(av,fill,Nullsv);
    }
}
Commit	Line	Data
79072805	1	/* $RCSfile: array.c,v $$Revision: 4.1 $$Date: 92/08/07 17:18:22 $
	2	*
	3	* Copyright (c) 1991, Larry Wall
	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	*
	8	* $Log: array.c,v $
	9	* Revision 4.1 92/08/07 17:18:22 lwall
	10	* Stage 6 Snapshot
	11	*
	12	* Revision 4.0.1.3 92/06/08 11:45:05 lwall
	13	* patch20: Perl now distinguishes overlapped copies from non-overlapped
	14	*
	15	* Revision 4.0.1.2 91/11/05 16:00:14 lwall
	16	* patch11: random cleanup
	17	* patch11: passing non-existend array elements to subrouting caused core dump
	18	*
	19	* Revision 4.0.1.1 91/06/07 10:19:08 lwall
	20	* patch4: new copyright notice
	21	*
	22	* Revision 4.0 91/03/20 01:03:32 lwall
	23	* 4.0 baseline.
	24	*
	25	*/
	26
	27	#include "EXTERN.h"
	28	#include "perl.h"
	29
	30	SV**
463ee0b2	31	av_fetch(av,key,lval)
463ee0b2	32	register AV *av;
79072805	33	I32 key;
	34	I32 lval;
	35	{
	36	SV *sv;
	37
463ee0b2	38	if (SvMAGICAL(av)) {
	39	if (mg_find((SV*)av,'P')) {
	40	if (key < 0)
	41	return 0;
	42	sv = sv_2mortal(NEWSV(61,0));
	43	mg_copy((SV*)av, sv, 0, key);
	44	if (!lval) {
	45	mg_get((SV*)sv);
	46	sv_unmagic(sv,'p');
	47	}
	48	Sv = sv;
	49	return &Sv;
	50	}
	51	}
	52
	53	if (key < 0 \|\| key > AvFILL(av)) {
ed6116ce	54	if (key < 0) {
	55	key += AvFILL(av) + 1;
	56	if (key < 0)
	57	return 0;
	58	}
	59	else {
	60	if (!lval)
	61	return 0;
463ee0b2	62	if (AvREAL(av))
79072805	63	sv = NEWSV(5,0);
	64	else
	65	sv = sv_mortalcopy(&sv_undef);
463ee0b2	66	return av_store(av,key,sv);
79072805	67	}
79072805	68	}
463ee0b2	69	if (!AvARRAY(av)[key]) {
79072805	70	if (lval) {
79072805	71	sv = NEWSV(6,0);
463ee0b2	72	return av_store(av,key,sv);
79072805	73	}
	74	return 0;
	75	}
463ee0b2	76	return &AvARRAY(av)[key];
79072805	77	}
	78
	79	SV**
463ee0b2	80	av_store(av,key,val)
463ee0b2	81	register AV *av;
79072805	82	I32 key;
	83	SV *val;
	84	{
	85	I32 tmp;
	86	SV** ary;
	87
ed6116ce	88	if (key < 0) {
	89	key += AvFILL(av) + 1;
	90	if (key < 0)
	91	return 0;
	92	}
463ee0b2	93
	94	if (SvMAGICAL(av)) {
	95	if (mg_find((SV*)av,'P')) {
	96	mg_copy((SV*)av, val, 0, key);
	97	return 0;
	98	}
	99	}
	100
	101	if (key > AvMAX(av)) {
79072805	102	I32 newmax;
79072805	103
463ee0b2	104	if (AvALLOC(av) != AvARRAY(av)) {
	105	tmp = AvARRAY(av) - AvALLOC(av);
	106	Move(AvARRAY(av), AvALLOC(av), AvMAX(av)+1, SV*);
	107	Zero(AvALLOC(av)+AvMAX(av)+1, tmp, SV*);
	108	AvMAX(av) += tmp;
	109	SvPVX(av) = (char*)(AvARRAY(av) - tmp);
	110	if (key > AvMAX(av) - 10) {
	111	newmax = key + AvMAX(av);
79072805	112	goto resize;
	113	}
	114	}
	115	else {
463ee0b2	116	if (AvALLOC(av)) {
463ee0b2	117	newmax = key + AvMAX(av) / 5;
79072805	118	resize:
463ee0b2	119	Renew(AvALLOC(av),newmax+1, SV*);
463ee0b2	120	Zero(&AvALLOC(av)[AvMAX(av)+1], newmax - AvMAX(av), SV*);
79072805	121	}
	122	else {
	123	newmax = key < 4 ? 4 : key;
463ee0b2	124	Newz(2,AvALLOC(av), newmax+1, SV*);
79072805	125	}
463ee0b2	126	SvPVX(av) = (char*)AvALLOC(av);
463ee0b2	127	AvMAX(av) = newmax;
79072805	128	}
79072805	129	}
463ee0b2	130	ary = AvARRAY(av);
	131	if (AvREAL(av)) {
	132	if (AvFILL(av) < key) {
	133	while (++AvFILL(av) < key) {
	134	if (ary[AvFILL(av)] != Nullsv) {
	135	sv_free(ary[AvFILL(av)]);
	136	ary[AvFILL(av)] = Nullsv;
79072805	137	}
	138	}
	139	}
	140	if (ary[key])
	141	sv_free(ary[key]);
	142	}
	143	ary[key] = val;
463ee0b2	144	if (SvMAGICAL(av)) {
	145	MAGIC* mg = SvMAGIC(av);
	146	sv_magic(val, (SV*)av, tolower(mg->mg_type), 0, key);
	147	mg_set((SV*)av);
	148	}
79072805	149	return &ary[key];
	150	}
	151
	152	AV *
	153	newAV()
	154	{
463ee0b2	155	register AV *av;
79072805	156
463ee0b2	157	Newz(1,av,1,AV);
	158	SvREFCNT(av) = 1;
	159	sv_upgrade(av,SVt_PVAV);
	160	AvREAL_on(av);
	161	AvALLOC(av) = 0;
	162	SvPVX(av) = 0;
	163	AvMAX(av) = AvFILL(av) = -1;
	164	return av;
79072805	165	}
	166
	167	AV *
	168	av_make(size,strp)
	169	register I32 size;
	170	register SV **strp;
	171	{
463ee0b2	172	register AV *av;
79072805	173	register I32 i;
	174	register SV** ary;
	175
463ee0b2	176	Newz(3,av,1,AV);
463ee0b2	177	sv_upgrade(av,SVt_PVAV);
79072805	178	New(4,ary,size+1,SV*);
463ee0b2	179	AvALLOC(av) = ary;
79072805	180	Zero(ary,size,SV*);
463ee0b2	181	AvREAL_on(av);
	182	SvPVX(av) = (char*)ary;
	183	AvFILL(av) = size - 1;
	184	AvMAX(av) = size - 1;
79072805	185	for (i = 0; i < size; i++) {
	186	if (*strp) {
	187	ary[i] = NEWSV(7,0);
	188	sv_setsv(ary[i], *strp);
	189	}
	190	strp++;
	191	}
ed6116ce	192	SvOK_on(av);
463ee0b2	193	return av;
79072805	194	}
	195
	196	AV *
	197	av_fake(size,strp)
	198	register I32 size;
	199	register SV **strp;
	200	{
463ee0b2	201	register AV *av;
79072805	202	register SV** ary;
79072805	203
463ee0b2	204	Newz(3,av,1,AV);
	205	SvREFCNT(av) = 1;
	206	sv_upgrade(av,SVt_PVAV);
79072805	207	New(4,ary,size+1,SV*);
463ee0b2	208	AvALLOC(av) = ary;
79072805	209	Copy(strp,ary,size,SV*);
463ee0b2	210	AvREAL_off(av);
	211	SvPVX(av) = (char*)ary;
	212	AvFILL(av) = size - 1;
	213	AvMAX(av) = size - 1;
79072805	214	while (size--) {
	215	if (*strp)
	216	SvTEMP_off(*strp);
	217	strp++;
	218	}
ed6116ce	219	SvOK_on(av);
463ee0b2	220	return av;
79072805	221	}
	222
	223	void
463ee0b2	224	av_clear(av)
463ee0b2	225	register AV *av;
79072805	226	{
	227	register I32 key;
	228
463ee0b2	229	if (!av \|\| !AvREAL(av) \|\| AvMAX(av) < 0)
79072805	230	return;
79072805	231	/SUPPRESS 560/
463ee0b2	232	if (key = AvARRAY(av) - AvALLOC(av)) {
	233	AvMAX(av) += key;
	234	SvPVX(av) = (char*)(AvARRAY(av) - key);
79072805	235	}
463ee0b2	236	for (key = 0; key <= AvMAX(av); key++)
	237	sv_free(AvARRAY(av)[key]);
	238	AvFILL(av) = -1;
	239	Zero(AvARRAY(av), AvMAX(av)+1, SV*);
79072805	240	}
	241
	242	void
463ee0b2	243	av_undef(av)
463ee0b2	244	register AV *av;
79072805	245	{
	246	register I32 key;
	247
463ee0b2	248	if (!av)
79072805	249	return;
79072805	250	/SUPPRESS 560/
463ee0b2	251	if (key = AvARRAY(av) - AvALLOC(av)) {
	252	AvMAX(av) += key;
	253	SvPVX(av) = (char*)(AvARRAY(av) - key);
79072805	254	}
463ee0b2	255	if (AvREAL(av)) {
	256	for (key = 0; key <= AvMAX(av); key++)
	257	sv_free(AvARRAY(av)[key]);
79072805	258	}
463ee0b2	259	Safefree(AvALLOC(av));
	260	AvALLOC(av) = 0;
	261	SvPVX(av) = 0;
	262	AvMAX(av) = AvFILL(av) = -1;
79072805	263	}
	264
	265	void
463ee0b2	266	av_free(av)
463ee0b2	267	AV *av;
79072805	268	{
463ee0b2	269	av_undef(av);
463ee0b2	270	Safefree(av);
79072805	271	}
	272
	273	bool
463ee0b2	274	av_push(av,val)
463ee0b2	275	register AV *av;
79072805	276	SV *val;
79072805	277	{
463ee0b2	278	return av_store(av,++(AvFILL(av)),val) != 0;
79072805	279	}
	280
	281	SV *
463ee0b2	282	av_pop(av)
463ee0b2	283	register AV *av;
79072805	284	{
	285	SV *retval;
	286
463ee0b2	287	if (AvFILL(av) < 0)
79072805	288	return Nullsv;
463ee0b2	289	retval = AvARRAY(av)[AvFILL(av)];
	290	AvARRAY(av)[AvFILL(av)--] = Nullsv;
	291	if (SvMAGICAL(av))
	292	mg_set((SV*)av);
79072805	293	return retval;
	294	}
	295
	296	void
463ee0b2	297	av_popnulls(av)
463ee0b2	298	register AV *av;
79072805	299	{
463ee0b2	300	register I32 fill = AvFILL(av);
79072805	301
463ee0b2	302	while (fill >= 0 && !AvARRAY(av)[fill])
79072805	303	fill--;
463ee0b2	304	AvFILL(av) = fill;
79072805	305	}
	306
	307	void
463ee0b2	308	av_unshift(av,num)
463ee0b2	309	register AV *av;
79072805	310	register I32 num;
	311	{
	312	register I32 i;
	313	register SV sstr,dstr;
	314
	315	if (num <= 0)
	316	return;
463ee0b2	317	if (AvARRAY(av) - AvALLOC(av) >= num) {
	318	AvMAX(av) += num;
	319	AvFILL(av) += num;
	320	while (num--) {
	321	SvPVX(av) = (char*)(AvARRAY(av) - 1);
	322	*AvARRAY(av) = Nullsv;
	323	}
79072805	324	}
79072805	325	else {
463ee0b2	326	(void)av_store(av,AvFILL(av)+num,(SV)0); / maybe extend array */
463ee0b2	327	dstr = AvARRAY(av) + AvFILL(av);
79072805	328	sstr = dstr - num;
	329	#ifdef BUGGY_MSC5
	330	# pragma loop_opt(off) /* don't loop-optimize the following code */
	331	#endif /* BUGGY_MSC5 */
463ee0b2	332	for (i = AvFILL(av) - num; i >= 0; i--) {
79072805	333	dstr-- = sstr--;
	334	#ifdef BUGGY_MSC5
	335	# pragma loop_opt() /* loop-optimization back to command-line setting */
	336	#endif /* BUGGY_MSC5 */
	337	}
463ee0b2	338	Zero(AvARRAY(av), num, SV*);
79072805	339	}
	340	}
	341
	342	SV *
463ee0b2	343	av_shift(av)
463ee0b2	344	register AV *av;
79072805	345	{
	346	SV *retval;
	347
463ee0b2	348	if (AvFILL(av) < 0)
79072805	349	return Nullsv;
463ee0b2	350	retval = *AvARRAY(av);
	351	*AvARRAY(av) = Nullsv;
	352	SvPVX(av) = (char*)(AvARRAY(av) + 1);
	353	AvMAX(av)--;
	354	AvFILL(av)--;
	355	if (SvMAGICAL(av))
	356	mg_set((SV*)av);
79072805	357	return retval;
	358	}
	359
	360	I32
463ee0b2	361	av_len(av)
463ee0b2	362	register AV *av;
79072805	363	{
463ee0b2	364	return AvFILL(av);
79072805	365	}
	366
	367	void
463ee0b2	368	av_fill(av, fill)
463ee0b2	369	register AV *av;
79072805	370	I32 fill;
	371	{
	372	if (fill < 0)
	373	fill = -1;
463ee0b2	374	if (fill <= AvMAX(av)) {
	375	AvFILL(av) = fill;
	376	if (SvMAGICAL(av))
	377	mg_set((SV*)av);
	378	}
79072805	379	else {
463ee0b2	380	AvFILL(av) = fill - 1; /* don't clobber in-between values */
463ee0b2	381	(void)av_store(av,fill,Nullsv);
79072805	382	}
79072805	383	}