/* regexec.c - regular expression handling *//*modification history--------------------01e,13apr98,wmd  rename regexec to wtxRegExec for hosts.01f,23mar98,fle  warnings eradication01e,02mar98,pcn  Removed warnings.01d,30sep96,elp  put in share, adapted to be compiled on target side		 (SPR# 6775).01c,10jul96,pad   undefined redefinition of malloc (AIX specific).01b,20mar95,p_m   moved #include "host.h" on top of includes list, this is		  necessary on Windows platforms.                         changed #include <regex.h> to #include "regex.h".01a,10jan95,jcf   created.*//*DESCRIPTIONThis library is *not* the original BSD distribution.  Though the changeswere completely cosmetic (file naming, and such), the user of this libraryis forewarned.AUTHOR: Henry Spencer*//*- * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 *	The Regents of the University of California.  All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *	This product includes software developed by the University of *	California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * *	@(#)regexec.c	8.3 (Berkeley) 3/20/94 */#if defined(LIBC_SCCS) && !defined(lint)static char sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";#endif /* LIBC_SCCS and not lint *//* * the outer shell of regexec() * * This file includes regcore.c *twice*, after muchos fiddling with the * macros that code uses.  This lets the same code operate on two different * representations for state sets. */#ifdef HOST#include "host.h"#if defined(RS6000_AIX4) || defined (RS6000_AIX3)#undef malloc#endif#include <sys/types.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <limits.h>#include <ctype.h>#else#include "vxWorks.h"#include "stdio.h"#include "string.h"#include "ctype.h"#include "limits.h"#include "stdlib.h"#endif /* HOST */#include "regex.h"#include "regex2.h"static int nope = 0;		/* for use in asserts; shuts lint up *//* macros for manipulating states, small version */#define	states	long#define	states1	states		/* for later use in regexec() decision */#define	CLEAR(v)	((v) = 0)#define	SET0(v, n)	((v) &= ~(1 << (n)))#define	SET1(v, n)	((v) |= 1 << (n))#define	ISSET(v, n)	((v) & (1 << (n)))#define	ASSIGN(d, s)	((d) = (s))#define	EQ(a, b)	((a) == (b))#define	STATEVARS	int dummy	/* dummy version */#define	STATESETUP(m, n)	/* nothing */#define	STATETEARDOWN(m)	/* nothing */#define	SETUP(v)	((v) = 0)#define	onestate	int#define	INIT(o, n)	((o) = (unsigned)1 << (n))#define	INC(o)	((o) <<= 1)#define	ISSTATEIN(v, o)	((v) & (o))/* some abbreviations; note that some of these know variable names! *//* do "if I'm here, I can also be there" etc without branches */#define	FWD(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) << (n))#define	BACK(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) >> (n))#define	ISSETBACK(v, n)	((v) & ((unsigned)here >> (n)))/* function names */#define SNAMES			/* regcore.c looks after details */#include "regcore.c"/* now undo things */#undef	states#undef	CLEAR#undef	SET0#undef	SET1#undef	ISSET#undef	ASSIGN#undef	EQ#undef	STATEVARS#undef	STATESETUP#undef	STATETEARDOWN#undef	SETUP#undef	onestate#undef	INIT#undef	INC#undef	ISSTATEIN#undef	FWD#undef	BACK#undef	ISSETBACK#undef	SNAMES/* macros for manipulating states, large version */#define	states	char *#define	CLEAR(v)	memset(v, 0, m->g->nstates)#define	SET0(v, n)	((v)[n] = 0)#define	SET1(v, n)	((v)[n] = 1)#define	ISSET(v, n)	((v)[n])#define	ASSIGN(d, s)	memcpy(d, s, m->g->nstates)#define	EQ(a, b)	(memcmp(a, b, m->g->nstates) == 0)#define	STATEVARS	int vn; char *space#define	STATESETUP(m, nv)	{ (m)->space = malloc((nv)*(m)->g->nstates); \				if ((m)->space == NULL) return(REG_ESPACE); \				(m)->vn = 0; }#define	STATETEARDOWN(m)	{ free((m)->space); }#define	SETUP(v)	((v) = &m->space[m->vn++ * m->g->nstates])#define	onestate	int#define	INIT(o, n)	((o) = (n))#define	INC(o)	((o)++)#define	ISSTATEIN(v, o)	((v)[o])/* some abbreviations; note that some of these know variable names! *//* do "if I'm here, I can also be there" etc without branches */#define	FWD(dst, src, n)	((dst)[here+(n)] |= (src)[here])#define	BACK(dst, src, n)	((dst)[here-(n)] |= (src)[here])#define	ISSETBACK(v, n)	((v)[here - (n)])/* function names */#define	LNAMES			/* flag */#include "regcore.c"/* - regexec - interface for matching = extern int regexec(const regex_t *, const char *, size_t, \ =					regmatch_t [], int); = #define	REG_NOTBOL	00001 = #define	REG_NOTEOL	00002 = #define	REG_STARTEND	00004 = #define	REG_TRACE	00400	// tracing of execution = #define	REG_LARGE	01000	// force large representation = #define	REG_BACKR	02000	// force use of backref code * * We put this here so we can exploit knowledge of the state representation * when choosing which matcher to call.  Also, by this point the matchers * have been prototyped. */int				/* 0 success, REG_NOMATCH failure */#ifdef HOSTwtxRegExec(preg, string, nmatch, pmatch, eflags)#elseregexec(preg, string, nmatch, pmatch, eflags)#endifconst regex_t *preg;const char *string;size_t nmatch;regmatch_t pmatch[];int eflags;{	register struct re_guts *g = preg->re_g;#ifdef REDEBUG#	define	GOODFLAGS(f)	(f)#else#	define	GOODFLAGS(f)	((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))#endif	nope = 0;	/* XXX jcf: remove warning */	if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)		return(REG_BADPAT);	assert(!(g->iflags&BAD));	if (g->iflags&BAD)		/* backstop for no-debug case */		return(REG_BADPAT);	eflags = GOODFLAGS(eflags);	if ( (int) g->nstates <= (int) (CHAR_BIT*sizeof (states1)) &&	    ! (eflags&REG_LARGE))		return(smatcher(g, (char *)string, nmatch, pmatch, eflags));	else		return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));}