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

int
do_match(TARG,arg,gimme,arglast)
STR *TARG;
register ARG *arg;
int gimme;
int *arglast;
{
    register STR **st = stack->ary_array;
    register SPAT *spat = arg[2].arg_ptr.arg_spat;
    register char *t;
    register int sp = arglast[0] + 1;
    STR *srchstr = st[sp];
    register char *s = str_get(st[sp]);
    char *strend = s + st[sp]->str_cur;
    STR *tmpstr;
    char *myhint = hint;
    int global;
    int safebase;
    char *truebase = s;
    register REGEXP *rx = spat->spat_regexp;

    hint = Nullch;
    if (!spat) {
	if (gimme == G_ARRAY)
	    return --sp;
	str_set(TARG,Yes);
	STABSET(TARG);
	st[sp] = TARG;
	return sp;
    }
    global = spat->spat_flags & SPAT_GLOBAL;
    safebase = (gimme == G_ARRAY) || global;
    if (!s)
	fatal("panic: do_match");
    if (spat->spat_flags & SPAT_USED) {
#ifdef DEBUGGING
	if (debug & 8)
	    deb("2.SPAT USED\n");
#endif
	if (gimme == G_ARRAY)
	    return --sp;
	str_set(TARG,No);
	STABSET(TARG);
	st[sp] = TARG;
	return sp;
    }
    --sp;
    if (spat->spat_runtime) {
	nointrp = "|)";
	sp = eval(spat->spat_runtime,G_SCALAR,sp);
	st = stack->ary_array;
	t = str_get(tmpstr = st[sp--]);
	nointrp = "";
#ifdef DEBUGGING
	if (debug & 8)
	    deb("2.SPAT /%s/\n",t);
#endif
	if (!global && rx)
	    regfree(rx);
	spat->spat_regexp = Null(REGEXP*);	/* crucial if regcomp aborts */
	spat->spat_regexp = regcomp(t,t+tmpstr->str_cur,
	    spat->spat_flags & SPAT_FOLD);
	if (!spat->spat_regexp->prelen && lastspat)
	    spat = lastspat;
	if (spat->spat_flags & SPAT_KEEP) {
	    if (!(spat->spat_flags & SPAT_FOLD))
		scanconst(spat,spat->spat_regexp->precomp,
		    spat->spat_regexp->prelen);
	    if (spat->spat_runtime)
		arg_free(spat->spat_runtime);	/* it won't change, so */
	    spat->spat_runtime = Nullarg;	/* no point compiling again */
	    hoistmust(spat);
	    if (curcmd->c_expr && (curcmd->c_flags & CF_OPTIMIZE) == CFT_EVAL) {
		curcmd->c_flags &= ~CF_OPTIMIZE;
		opt_arg(curcmd, 1, curcmd->c_type == C_EXPR);
	    }
	}
	if (global) {
	    if (rx) {
	        if (rx->startp[0]) {
		    s = rx->endp[0];
		    if (s == rx->startp[0])
			s++;
		    if (s > strend) {
			regfree(rx);
			rx = spat->spat_regexp;
			goto nope;
		    }
		}
		regfree(rx);
	    }
	}
	else if (!spat->spat_regexp->nparens)
	    gimme = G_SCALAR;			/* accidental array context? */
	rx = spat->spat_regexp;
	if (regexec(rx, s, strend, s, 0,
	  srchstr->str_pok & SP_STUDIED ? srchstr : Nullstr,
	  safebase)) {
	    if (rx->subbase || global)
		curspat = spat;
	    lastspat = spat;
	    goto gotcha;
	}
	else {
	    if (gimme == G_ARRAY)
		return sp;
	    str_sset(TARG,&str_no);
	    STABSET(TARG);
	    st[++sp] = TARG;
	    return sp;
	}
    }
    else {
#ifdef DEBUGGING
	if (debug & 8) {
	    char ch;

	    if (spat->spat_flags & SPAT_ONCE)
		ch = '?';
	    else
		ch = '/';
	    deb("2.SPAT %c%s%c\n",ch,rx->precomp,ch);
	}
#endif
	if (!rx->prelen && lastspat) {
	    spat = lastspat;
	    rx = spat->spat_regexp;
	}
	t = s;
    play_it_again:
	if (global && rx->startp[0]) {
	    t = s = rx->endp[0];
	    if (s == rx->startp[0])
		s++,t++;
	    if (s > strend)
		goto nope;
	}
	if (myhint) {
	    if (myhint < s || myhint > strend)
		fatal("panic: hint in do_match");
	    s = myhint;
	    if (rx->regback >= 0) {
		s -= rx->regback;
		if (s < t)
		    s = t;
	    }
	    else
		s = t;
	}
	else if (spat->spat_short) {
	    if (spat->spat_flags & SPAT_SCANFIRST) {
		if (srchstr->str_pok & SP_STUDIED) {
		    if (screamfirst[spat->spat_short->str_rare] < 0)
			goto nope;
		    else if (!(s = screaminstr(srchstr,spat->spat_short)))
			goto nope;
		    else if (spat->spat_flags & SPAT_ALL)
			goto yup;
		}
#ifndef lint
		else if (!(s = fbminstr((unsigned char*)s,
		  (unsigned char*)strend, spat->spat_short)))
		    goto nope;
#endif
		else if (spat->spat_flags & SPAT_ALL)
		    goto yup;
		if (s && rx->regback >= 0) {
		    ++spat->spat_short->str_u.str_useful;
		    s -= rx->regback;
		    if (s < t)
			s = t;
		}
		else
		    s = t;
	    }
	    else if (!multiline && (*spat->spat_short->str_ptr != *s ||
	      bcmp(spat->spat_short->str_ptr, s, spat->spat_slen) ))
		goto nope;
	    if (--spat->spat_short->str_u.str_useful < 0) {
		str_free(spat->spat_short);
		spat->spat_short = Nullstr;	/* opt is being useless */
	    }
	}
	if (!rx->nparens && !global) {
	    gimme = G_SCALAR;			/* accidental array context? */
	    safebase = FALSE;
	}
	if (regexec(rx, s, strend, truebase, 0,
	  srchstr->str_pok & SP_STUDIED ? srchstr : Nullstr,
	  safebase)) {
	    if (rx->subbase || global)
		curspat = spat;
	    lastspat = spat;
	    if (spat->spat_flags & SPAT_ONCE)
		spat->spat_flags |= SPAT_USED;
	    goto gotcha;
	}
	else {
	    if (global)
		rx->startp[0] = Nullch;
	    if (gimme == G_ARRAY)
		return sp;
	    str_sset(TARG,&str_no);
	    STABSET(TARG);
	    st[++sp] = TARG;
	    return sp;
	}
    }
    /*NOTREACHED*/

  gotcha:
    if (gimme == G_ARRAY) {
	int iters, i, len;

	iters = rx->nparens;
	if (global && !iters)
	    i = 1;
	else
	    i = 0;
	if (sp + iters + i >= stack->ary_max) {
	    astore(stack,sp + iters + i, Nullstr);
	    st = stack->ary_array;		/* possibly realloced */
	}

	for (i = !i; i <= iters; i++) {
	    st[++sp] = str_mortal(&str_no);
	    /*SUPPRESS 560*/
	    if (s = rx->startp[i]) {
		len = rx->endp[i] - s;
		if (len > 0)
		    str_nset(st[sp],s,len);
	    }
	}
	if (global) {
	    truebase = rx->subbeg;
	    goto play_it_again;
	}
	return sp;
    }
    else {
	str_sset(TARG,&str_yes);
	STABSET(TARG);
	st[++sp] = TARG;
	return sp;
    }

yup:
    ++spat->spat_short->str_u.str_useful;
    lastspat = spat;
    if (spat->spat_flags & SPAT_ONCE)
	spat->spat_flags |= SPAT_USED;
    if (global) {
	rx->subbeg = t;
	rx->subend = strend;
	rx->startp[0] = s;
	rx->endp[0] = s + spat->spat_short->str_cur;
	curspat = spat;
	goto gotcha;
    }
    if (sawampersand) {
	char *tmps;

	if (rx->subbase)
	    Safefree(rx->subbase);
	tmps = rx->subbase = nsavestr(t,strend-t);
	rx->subbeg = tmps;
	rx->subend = tmps + (strend-t);
	tmps = rx->startp[0] = tmps + (s - t);
	rx->endp[0] = tmps + spat->spat_short->str_cur;
	curspat = spat;
    }
    str_sset(TARG,&str_yes);
    STABSET(TARG);
    st[++sp] = TARG;
    return sp;

nope:
    rx->startp[0] = Nullch;
    if (spat->spat_short)
	++spat->spat_short->str_u.str_useful;
    if (gimme == G_ARRAY)
	return sp;
    str_sset(TARG,&str_no);
    STABSET(TARG);
    st[++sp] = TARG;
    return sp;
}
Commit	Line	Data
79072805	1	int
	2	do_match(TARG,arg,gimme,arglast)
	3	STR *TARG;
	4	register ARG *arg;
	5	int gimme;
	6	int *arglast;
	7	{
	8	register STR **st = stack->ary_array;
	9	register SPAT *spat = arg[2].arg_ptr.arg_spat;
	10	register char *t;
	11	register int sp = arglast[0] + 1;
	12	STR *srchstr = st[sp];
	13	register char *s = str_get(st[sp]);
	14	char *strend = s + st[sp]->str_cur;
	15	STR *tmpstr;
	16	char *myhint = hint;
	17	int global;
	18	int safebase;
	19	char *truebase = s;
	20	register REGEXP *rx = spat->spat_regexp;
	21
	22	hint = Nullch;
	23	if (!spat) {
	24	if (gimme == G_ARRAY)
	25	return --sp;
	26	str_set(TARG,Yes);
	27	STABSET(TARG);
	28	st[sp] = TARG;
	29	return sp;
	30	}
	31	global = spat->spat_flags & SPAT_GLOBAL;
	32	safebase = (gimme == G_ARRAY) \|\| global;
	33	if (!s)
	34	fatal("panic: do_match");
	35	if (spat->spat_flags & SPAT_USED) {
	36	#ifdef DEBUGGING
	37	if (debug & 8)
	38	deb("2.SPAT USED\n");
	39	#endif
	40	if (gimme == G_ARRAY)
	41	return --sp;
	42	str_set(TARG,No);
	43	STABSET(TARG);
	44	st[sp] = TARG;
	45	return sp;
	46	}
	47	--sp;
	48	if (spat->spat_runtime) {
	49	nointrp = "\|)";
	50	sp = eval(spat->spat_runtime,G_SCALAR,sp);
	51	st = stack->ary_array;
	52	t = str_get(tmpstr = st[sp--]);
	53	nointrp = "";
	54	#ifdef DEBUGGING
	55	if (debug & 8)
	56	deb("2.SPAT /%s/\n",t);
	57	#endif
	58	if (!global && rx)
	59	regfree(rx);
	60	spat->spat_regexp = Null(REGEXP); / crucial if regcomp aborts */
	61	spat->spat_regexp = regcomp(t,t+tmpstr->str_cur,
	62	spat->spat_flags & SPAT_FOLD);
	63	if (!spat->spat_regexp->prelen && lastspat)
	64	spat = lastspat;
65	if (spat->spat_flags & SPAT_KEEP) {
66	if (!(spat->spat_flags & SPAT_FOLD))
67	scanconst(spat,spat->spat_regexp->precomp,
68	spat->spat_regexp->prelen);
69	if (spat->spat_runtime)
70	arg_free(spat->spat_runtime); /* it won't change, so */
71	spat->spat_runtime = Nullarg; /* no point compiling again */
72	hoistmust(spat);
73	if (curcmd->c_expr && (curcmd->c_flags & CF_OPTIMIZE) == CFT_EVAL) {
74	curcmd->c_flags &= ~CF_OPTIMIZE;
75	opt_arg(curcmd, 1, curcmd->c_type == C_EXPR);
76	}
77	}
78	if (global) {
79	if (rx) {
80	if (rx->startp[0]) {
81	s = rx->endp[0];
82	if (s == rx->startp[0])
83	s++;
84	if (s > strend) {
85	regfree(rx);
86	rx = spat->spat_regexp;
87	goto nope;
88	}
89	}
90	regfree(rx);
91	}
92	}
93	else if (!spat->spat_regexp->nparens)
94	gimme = G_SCALAR; /* accidental array context? */
95	rx = spat->spat_regexp;
96	if (regexec(rx, s, strend, s, 0,
97	srchstr->str_pok & SP_STUDIED ? srchstr : Nullstr,
98	safebase)) {
99	if (rx->subbase \|\| global)
100	curspat = spat;
101	lastspat = spat;
102	goto gotcha;
103	}
104	else {
105	if (gimme == G_ARRAY)
106	return sp;
107	str_sset(TARG,&str_no);
108	STABSET(TARG);
109	st[++sp] = TARG;
110	return sp;
111	}
112	}
113	else {
114	#ifdef DEBUGGING
115	if (debug & 8) {
116	char ch;
117
118	if (spat->spat_flags & SPAT_ONCE)
119	ch = '?';
120	else
121	ch = '/';
122	deb("2.SPAT %c%s%c\n",ch,rx->precomp,ch);
123	}
124	#endif
125	if (!rx->prelen && lastspat) {
126	spat = lastspat;
127	rx = spat->spat_regexp;
128	}
129	t = s;
130	play_it_again:
131	if (global && rx->startp[0]) {
132	t = s = rx->endp[0];
133	if (s == rx->startp[0])
134	s++,t++;
135	if (s > strend)
136	goto nope;
137	}
138	if (myhint) {
139	if (myhint < s \|\| myhint > strend)
140	fatal("panic: hint in do_match");
141	s = myhint;
142	if (rx->regback >= 0) {
143	s -= rx->regback;
144	if (s < t)
145	s = t;
146	}
147	else
148	s = t;
149	}
150	else if (spat->spat_short) {
151	if (spat->spat_flags & SPAT_SCANFIRST) {
152	if (srchstr->str_pok & SP_STUDIED) {
153	if (screamfirst[spat->spat_short->str_rare] < 0)
154	goto nope;
155	else if (!(s = screaminstr(srchstr,spat->spat_short)))
156	goto nope;
157	else if (spat->spat_flags & SPAT_ALL)
158	goto yup;
159	}
160	#ifndef lint
161	else if (!(s = fbminstr((unsigned char*)s,
162	(unsigned char*)strend, spat->spat_short)))
163	goto nope;
164	#endif
165	else if (spat->spat_flags & SPAT_ALL)
166	goto yup;
167	if (s && rx->regback >= 0) {
168	++spat->spat_short->str_u.str_useful;
169	s -= rx->regback;
170	if (s < t)
171	s = t;
172	}
173	else
174	s = t;
175	}
176	else if (!multiline && (spat->spat_short->str_ptr != s \|\|
177	bcmp(spat->spat_short->str_ptr, s, spat->spat_slen) ))
178	goto nope;
179	if (--spat->spat_short->str_u.str_useful < 0) {
180	str_free(spat->spat_short);
181	spat->spat_short = Nullstr; /* opt is being useless */
182	}
183	}
184	if (!rx->nparens && !global) {
185	gimme = G_SCALAR; /* accidental array context? */
186	safebase = FALSE;
187	}
188	if (regexec(rx, s, strend, truebase, 0,
189	srchstr->str_pok & SP_STUDIED ? srchstr : Nullstr,
190	safebase)) {
191	if (rx->subbase \|\| global)
192	curspat = spat;
193	lastspat = spat;
194	if (spat->spat_flags & SPAT_ONCE)
195	spat->spat_flags \|= SPAT_USED;
196	goto gotcha;
197	}
198	else {
199	if (global)
200	rx->startp[0] = Nullch;
201	if (gimme == G_ARRAY)
202	return sp;
203	str_sset(TARG,&str_no);
204	STABSET(TARG);
205	st[++sp] = TARG;
206	return sp;
207	}
208	}
209	/NOTREACHED/
210
211	gotcha:
212	if (gimme == G_ARRAY) {
213	int iters, i, len;
214
215	iters = rx->nparens;
216	if (global && !iters)
217	i = 1;
218	else
219	i = 0;
220	if (sp + iters + i >= stack->ary_max) {
221	astore(stack,sp + iters + i, Nullstr);
222	st = stack->ary_array; /* possibly realloced */
223	}
224
225	for (i = !i; i <= iters; i++) {
226	st[++sp] = str_mortal(&str_no);
227	/SUPPRESS 560/
228	if (s = rx->startp[i]) {
229	len = rx->endp[i] - s;
230	if (len > 0)
231	str_nset(st[sp],s,len);
232	}
233	}
234	if (global) {
235	truebase = rx->subbeg;
236	goto play_it_again;
237	}
238	return sp;
239	}
240	else {
241	str_sset(TARG,&str_yes);
242	STABSET(TARG);
243	st[++sp] = TARG;
244	return sp;
245	}
246
247	yup:
248	++spat->spat_short->str_u.str_useful;
249	lastspat = spat;
250	if (spat->spat_flags & SPAT_ONCE)
251	spat->spat_flags \|= SPAT_USED;
252	if (global) {
253	rx->subbeg = t;
254	rx->subend = strend;
255	rx->startp[0] = s;
256	rx->endp[0] = s + spat->spat_short->str_cur;
257	curspat = spat;
258	goto gotcha;
259	}
260	if (sawampersand) {
261	char *tmps;
262
263	if (rx->subbase)
264	Safefree(rx->subbase);
265	tmps = rx->subbase = nsavestr(t,strend-t);
266	rx->subbeg = tmps;
267	rx->subend = tmps + (strend-t);
268	tmps = rx->startp[0] = tmps + (s - t);
269	rx->endp[0] = tmps + spat->spat_short->str_cur;
270	curspat = spat;
271	}
272	str_sset(TARG,&str_yes);
273	STABSET(TARG);
274	st[++sp] = TARG;
275	return sp;
276
277	nope:
278	rx->startp[0] = Nullch;
279	if (spat->spat_short)
280	++spat->spat_short->str_u.str_useful;
281	if (gimme == G_ARRAY)
282	return sp;
283	str_sset(TARG,&str_no);
284	STABSET(TARG);
285	st[++sp] = TARG;
286	return sp;
287	}
288