[p5sagit/p5-mst-13.2.git] / do / split

int
do_split(TARG,spat,limit,gimme,arglast)
STR *TARG;
register SPAT *spat;
register int limit;
int gimme;
int *arglast;
{
    register ARRAY *ary = stack;
    STR **st = ary->ary_array;
    register int sp = arglast[0] + 1;
    register char *s = str_get(st[sp]);
    char *strend = s + st[sp--]->str_cur;
    register STR *dstr;
    register char *m;
    int iters = 0;
    int maxiters = (strend - s) + 10;
    int i;
    char *orig;
    int origlimit = limit;
    int realarray = 0;

    if (!spat || !s)
	fatal("panic: do_split");
    else if (spat->spat_runtime) {
	nointrp = "|)";
	sp = eval(spat->spat_runtime,G_SCALAR,sp);
	st = stack->ary_array;
	m = str_get(dstr = st[sp--]);
	nointrp = "";
	if (*m == ' ' && dstr->str_cur == 1) {
	    str_set(dstr,"\\s+");
	    m = dstr->str_ptr;
	    spat->spat_flags |= SPAT_SKIPWHITE;
	}
	if (spat->spat_regexp) {
	    regfree(spat->spat_regexp);
	    spat->spat_regexp = Null(REGEXP*);	/* avoid possible double free */
	}
	spat->spat_regexp = regcomp(m,m+dstr->str_cur,
	    spat->spat_flags & SPAT_FOLD);
	if (spat->spat_flags & SPAT_KEEP ||
	    (spat->spat_runtime->arg_type == O_ITEM &&
	      (spat->spat_runtime[1].arg_type & A_MASK) == A_SINGLE) ) {
	    arg_free(spat->spat_runtime);	/* it won't change, so */
	    spat->spat_runtime = Nullarg;	/* no point compiling again */
	}
    }
#ifdef DEBUGGING
    if (debug & 8) {
	deb("2.SPAT /%s/\n",spat->spat_regexp->precomp);
    }
#endif
    ary = stab_xarray(spat->spat_repl[1].arg_ptr.arg_stab);
    if (ary && (gimme != G_ARRAY || (spat->spat_flags & SPAT_ONCE))) {
	realarray = 1;
	if (!(ary->ary_flags & ARF_REAL)) {
	    ary->ary_flags |= ARF_REAL;
	    for (i = ary->ary_fill; i >= 0; i--)
		ary->ary_array[i] = Nullstr;	/* don't free mere refs */
	}
	ary->ary_fill = -1;
	sp = -1;	/* temporarily switch stacks */
    }
    else
	ary = stack;
    orig = s;
    if (spat->spat_flags & SPAT_SKIPWHITE) {
	while (isSPACE(*s))
	    s++;
    }
    if (!limit)
	limit = maxiters + 2;
    if (strEQ("\\s+",spat->spat_regexp->precomp)) {
	while (--limit) {
	    /*SUPPRESS 530*/
	    for (m = s; m < strend && !isSPACE(*m); m++) ;
	    if (m >= strend)
		break;
	    dstr = Str_new(30,m-s);
	    str_nset(dstr,s,m-s);
	    if (!realarray)
		str_2mortal(dstr);
	    (void)astore(ary, ++sp, dstr);
	    /*SUPPRESS 530*/
	    for (s = m + 1; s < strend && isSPACE(*s); s++) ;
	}
    }
    else if (strEQ("^",spat->spat_regexp->precomp)) {
	while (--limit) {
	    /*SUPPRESS 530*/
	    for (m = s; m < strend && *m != '\n'; m++) ;
	    m++;
	    if (m >= strend)
		break;
	    dstr = Str_new(30,m-s);
	    str_nset(dstr,s,m-s);
	    if (!realarray)
		str_2mortal(dstr);
	    (void)astore(ary, ++sp, dstr);
	    s = m;
	}
    }
    else if (spat->spat_short) {
	i = spat->spat_short->str_cur;
	if (i == 1) {
	    int fold = (spat->spat_flags & SPAT_FOLD);

	    i = *spat->spat_short->str_ptr;
	    if (fold && isUPPER(i))
		i = tolower(i);
	    while (--limit) {
		if (fold) {
		    for ( m = s;
			  m < strend && *m != i &&
			    (!isUPPER(*m) || tolower(*m) != i);
			  m++)			/*SUPPRESS 530*/
			;
		}
		else				/*SUPPRESS 530*/
		    for (m = s; m < strend && *m != i; m++) ;
		if (m >= strend)
		    break;
		dstr = Str_new(30,m-s);
		str_nset(dstr,s,m-s);
		if (!realarray)
		    str_2mortal(dstr);
		(void)astore(ary, ++sp, dstr);
		s = m + 1;
	    }
	}
	else {
#ifndef lint
	    while (s < strend && --limit &&
	      (m=fbminstr((unsigned char*)s, (unsigned char*)strend,
		    spat->spat_short)) )
#endif
	    {
		dstr = Str_new(31,m-s);
		str_nset(dstr,s,m-s);
		if (!realarray)
		    str_2mortal(dstr);
		(void)astore(ary, ++sp, dstr);
		s = m + i;
	    }
	}
    }
    else {
	maxiters += (strend - s) * spat->spat_regexp->nparens;
	while (s < strend && --limit &&
	    regexec(spat->spat_regexp, s, strend, orig, 1, Nullstr, TRUE) ) {
	    if (spat->spat_regexp->subbase
	      && spat->spat_regexp->subbase != orig) {
		m = s;
		s = orig;
		orig = spat->spat_regexp->subbase;
		s = orig + (m - s);
		strend = s + (strend - m);
	    }
	    m = spat->spat_regexp->startp[0];
	    dstr = Str_new(32,m-s);
	    str_nset(dstr,s,m-s);
	    if (!realarray)
		str_2mortal(dstr);
	    (void)astore(ary, ++sp, dstr);
	    if (spat->spat_regexp->nparens) {
		for (i = 1; i <= spat->spat_regexp->nparens; i++) {
		    s = spat->spat_regexp->startp[i];
		    m = spat->spat_regexp->endp[i];
		    dstr = Str_new(33,m-s);
		    str_nset(dstr,s,m-s);
		    if (!realarray)
			str_2mortal(dstr);
		    (void)astore(ary, ++sp, dstr);
		}
	    }
	    s = spat->spat_regexp->endp[0];
	}
    }
    if (realarray)
	iters = sp + 1;
    else
	iters = sp - arglast[0];
    if (iters > maxiters)
	fatal("Split loop");
    if (s < strend || origlimit) {	/* keep field after final delim? */
	dstr = Str_new(34,strend-s);
	str_nset(dstr,s,strend-s);
	if (!realarray)
	    str_2mortal(dstr);
	(void)astore(ary, ++sp, dstr);
	iters++;
    }
    else {
#ifndef I286x
	while (iters > 0 && ary->ary_array[sp]->str_cur == 0)
	    iters--,sp--;
#else
	char *zaps;
	int   zapb;

	if (iters > 0) {
		zaps = str_get(afetch(ary,sp,FALSE));
		zapb = (int) *zaps;
	}
	
	while (iters > 0 && (!zapb)) {
	    iters--,sp--;
	    if (iters > 0) {
		zaps = str_get(afetch(ary,iters-1,FALSE));
		zapb = (int) *zaps;
	    }
	}
#endif
    }
    if (realarray) {
	ary->ary_fill = sp;
	if (gimme == G_ARRAY) {
	    sp++;
	    astore(stack, arglast[0] + 1 + sp, Nullstr);
	    Copy(ary->ary_array, stack->ary_array + arglast[0] + 1, sp, STR*);
	    return arglast[0] + sp;
	}
    }
    else {
	if (gimme == G_ARRAY)
	    return sp;
    }
    sp = arglast[0] + 1;
    str_numset(TARG,(double)iters);
    STABSET(TARG);
    st[sp] = TARG;
    return sp;
}
Commit	Line	Data
79072805	1	int
	2	do_split(TARG,spat,limit,gimme,arglast)
	3	STR *TARG;
	4	register SPAT *spat;
	5	register int limit;
	6	int gimme;
	7	int *arglast;
	8	{
	9	register ARRAY *ary = stack;
	10	STR **st = ary->ary_array;
	11	register int sp = arglast[0] + 1;
	12	register char *s = str_get(st[sp]);
	13	char *strend = s + st[sp--]->str_cur;
	14	register STR *dstr;
	15	register char *m;
	16	int iters = 0;
	17	int maxiters = (strend - s) + 10;
	18	int i;
	19	char *orig;
	20	int origlimit = limit;
	21	int realarray = 0;
	22
	23	if (!spat \|\| !s)
	24	fatal("panic: do_split");
	25	else if (spat->spat_runtime) {
	26	nointrp = "\|)";
	27	sp = eval(spat->spat_runtime,G_SCALAR,sp);
	28	st = stack->ary_array;
	29	m = str_get(dstr = st[sp--]);
	30	nointrp = "";
	31	if (*m == ' ' && dstr->str_cur == 1) {
	32	str_set(dstr,"\\s+");
	33	m = dstr->str_ptr;
	34	spat->spat_flags \|= SPAT_SKIPWHITE;
	35	}
	36	if (spat->spat_regexp) {
	37	regfree(spat->spat_regexp);
	38	spat->spat_regexp = Null(REGEXP); / avoid possible double free */
	39	}
	40	spat->spat_regexp = regcomp(m,m+dstr->str_cur,
	41	spat->spat_flags & SPAT_FOLD);
	42	if (spat->spat_flags & SPAT_KEEP \|\|
	43	(spat->spat_runtime->arg_type == O_ITEM &&
	44	(spat->spat_runtime[1].arg_type & A_MASK) == A_SINGLE) ) {
	45	arg_free(spat->spat_runtime); /* it won't change, so */
	46	spat->spat_runtime = Nullarg; /* no point compiling again */
	47	}
	48	}
	49	#ifdef DEBUGGING
	50	if (debug & 8) {
	51	deb("2.SPAT /%s/\n",spat->spat_regexp->precomp);
	52	}
	53	#endif
	54	ary = stab_xarray(spat->spat_repl[1].arg_ptr.arg_stab);
	55	if (ary && (gimme != G_ARRAY \|\| (spat->spat_flags & SPAT_ONCE))) {
	56	realarray = 1;
	57	if (!(ary->ary_flags & ARF_REAL)) {
	58	ary->ary_flags \|= ARF_REAL;
	59	for (i = ary->ary_fill; i >= 0; i--)
	60	ary->ary_array[i] = Nullstr; /* don't free mere refs */
	61	}
	62	ary->ary_fill = -1;
	63	sp = -1; /* temporarily switch stacks */
	64	}
65	else
66	ary = stack;
67	orig = s;
68	if (spat->spat_flags & SPAT_SKIPWHITE) {
69	while (isSPACE(*s))
70	s++;
71	}
72	if (!limit)
73	limit = maxiters + 2;
74	if (strEQ("\\s+",spat->spat_regexp->precomp)) {
75	while (--limit) {
76	/SUPPRESS 530/
77	for (m = s; m < strend && !isSPACE(*m); m++) ;
78	if (m >= strend)
79	break;
80	dstr = Str_new(30,m-s);
81	str_nset(dstr,s,m-s);
82	if (!realarray)
83	str_2mortal(dstr);
84	(void)astore(ary, ++sp, dstr);
85	/SUPPRESS 530/
86	for (s = m + 1; s < strend && isSPACE(*s); s++) ;
87	}
88	}
89	else if (strEQ("^",spat->spat_regexp->precomp)) {
90	while (--limit) {
91	/SUPPRESS 530/
92	for (m = s; m < strend && *m != '\n'; m++) ;
93	m++;
94	if (m >= strend)
95	break;
96	dstr = Str_new(30,m-s);
97	str_nset(dstr,s,m-s);
98	if (!realarray)
99	str_2mortal(dstr);
100	(void)astore(ary, ++sp, dstr);
101	s = m;
102	}
103	}
104	else if (spat->spat_short) {
105	i = spat->spat_short->str_cur;
106	if (i == 1) {
107	int fold = (spat->spat_flags & SPAT_FOLD);
108
109	i = *spat->spat_short->str_ptr;
110	if (fold && isUPPER(i))
111	i = tolower(i);
112	while (--limit) {
113	if (fold) {
114	for ( m = s;
115	m < strend && *m != i &&
116	(!isUPPER(m) \|\| tolower(m) != i);
117	m++) /SUPPRESS 530/
118	;
119	}
120	else /SUPPRESS 530/
121	for (m = s; m < strend && *m != i; m++) ;
122	if (m >= strend)
123	break;
124	dstr = Str_new(30,m-s);
125	str_nset(dstr,s,m-s);
126	if (!realarray)
127	str_2mortal(dstr);
128	(void)astore(ary, ++sp, dstr);
129	s = m + 1;
130	}
131	}
132	else {
133	#ifndef lint
134	while (s < strend && --limit &&
135	(m=fbminstr((unsigned char)s, (unsigned char)strend,
136	spat->spat_short)) )
137	#endif
138	{
139	dstr = Str_new(31,m-s);
140	str_nset(dstr,s,m-s);
141	if (!realarray)
142	str_2mortal(dstr);
143	(void)astore(ary, ++sp, dstr);
144	s = m + i;
145	}
146	}
147	}
148	else {
149	maxiters += (strend - s) * spat->spat_regexp->nparens;
150	while (s < strend && --limit &&
151	regexec(spat->spat_regexp, s, strend, orig, 1, Nullstr, TRUE) ) {
152	if (spat->spat_regexp->subbase
153	&& spat->spat_regexp->subbase != orig) {
154	m = s;
155	s = orig;
156	orig = spat->spat_regexp->subbase;
157	s = orig + (m - s);
158	strend = s + (strend - m);
159	}
160	m = spat->spat_regexp->startp[0];
161	dstr = Str_new(32,m-s);
162	str_nset(dstr,s,m-s);
163	if (!realarray)
164	str_2mortal(dstr);
165	(void)astore(ary, ++sp, dstr);
166	if (spat->spat_regexp->nparens) {
167	for (i = 1; i <= spat->spat_regexp->nparens; i++) {
168	s = spat->spat_regexp->startp[i];
169	m = spat->spat_regexp->endp[i];
170	dstr = Str_new(33,m-s);
171	str_nset(dstr,s,m-s);
172	if (!realarray)
173	str_2mortal(dstr);
174	(void)astore(ary, ++sp, dstr);
175	}
176	}
177	s = spat->spat_regexp->endp[0];
178	}
179	}
180	if (realarray)
181	iters = sp + 1;
182	else
183	iters = sp - arglast[0];
184	if (iters > maxiters)
185	fatal("Split loop");
186	if (s < strend \|\| origlimit) { /* keep field after final delim? */
187	dstr = Str_new(34,strend-s);
188	str_nset(dstr,s,strend-s);
189	if (!realarray)
190	str_2mortal(dstr);
191	(void)astore(ary, ++sp, dstr);
192	iters++;
193	}
194	else {
195	#ifndef I286x
196	while (iters > 0 && ary->ary_array[sp]->str_cur == 0)
197	iters--,sp--;
198	#else
199	char *zaps;
200	int zapb;
201
202	if (iters > 0) {
203	zaps = str_get(afetch(ary,sp,FALSE));
204	zapb = (int) *zaps;
205	}
206
207	while (iters > 0 && (!zapb)) {
208	iters--,sp--;
209	if (iters > 0) {
210	zaps = str_get(afetch(ary,iters-1,FALSE));
211	zapb = (int) *zaps;
212	}
213	}
214	#endif
215	}
216	if (realarray) {
217	ary->ary_fill = sp;
218	if (gimme == G_ARRAY) {
219	sp++;
220	astore(stack, arglast[0] + 1 + sp, Nullstr);
221	Copy(ary->ary_array, stack->ary_array + arglast[0] + 1, sp, STR*);
222	return arglast[0] + sp;
223	}
224	}
225	else {
226	if (gimme == G_ARRAY)
227	return sp;
228	}
229	sp = arglast[0] + 1;
230	str_numset(TARG,(double)iters);
231	STABSET(TARG);
232	st[sp] = TARG;
233	return sp;
234	}
235