/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1985-2011 AT&T Intellectual Property          *

*                      and is licensed under the                       *

*                 Eclipse Public License, Version 1.0                  *

*                    by AT&T Intellectual Property                     *

*                                                                      *

*                A copy of the License is available at                 *

*          http://www.eclipse.org/org/documents/epl-v10.html           *

*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

*                                                                      *

*              Information and Software Systems Research               *

*                            AT&T Research                             *

*                           Florham Park NJ                            *

*                                                                      *

*                 Glenn Fowler <gsf@research.att.com>                  *

*                  David Korn <dgk@research.att.com>                   *

*                   Phong Vo <kpv@research.att.com>                    *

*                                                                      *

***********************************************************************/

#pragma prototyped

/*

 * regcomp() regex_t cache

 * at&t research

 */

#include <ast.h>

#include <regex.h>

#define CACHE		8		/* default # cached re's	*/

#define ROUND		64		/* pattern buffer size round	*/

typedef unsigned long Key_t;

typedef struct Cache_s

{

	char*		pattern;

	regex_t		re;

	unsigned long	serial;

	regflags_t	reflags;

	int		keep;

	int		size;

} Cache_t;

typedef struct State_s

{

	unsigned int	size;

	unsigned long	serial;

	char*		locale;

	Cache_t**	cache;

} State_t;

static State_t	matchstate;

/*

 * flush the cache

 */

static void

flushcache(void)

{

	register int		i;

	for (i = matchstate.size; i--;)

		if (matchstate.cache[i] && matchstate.cache[i]->keep)

		{

			matchstate.cache[i]->keep = 0;

			regfree(&matchstate.cache[i]->re);

		}

}

/*

 * return regcomp() compiled re for pattern and reflags

 */

regex_t*

regcache(const char* pattern, regflags_t reflags, int* status)

{

	register Cache_t*	cp;

	register int		i;

	char*			s;

	int			empty;

	int			unused;

	int			old;

	Key_t			key;

	/*

	 * 0 pattern flushes the cache and reflags>0 extends cache

	 */

	if (!pattern)

	{

		flushcache();

		i = 0;

		if (reflags > matchstate.size)

		{

			if (matchstate.cache = newof(matchstate.cache, Cache_t*, reflags, 0))

				matchstate.size = reflags;

			else

			{

				matchstate.size = 0;

				i = 1;

			}

		}

		if (status)

			*status = i;

		return 0;

	}

	if (!matchstate.cache)

	{

		if (!(matchstate.cache = newof(0, Cache_t*, CACHE, 0)))

			return 0;

		matchstate.size = CACHE;

	}

	/*

	 * flush the cache if the locale changed

	 * the ast setlocale() intercept maintains

	 * persistent setlocale() return values

	 */

	if ((s = setlocale(LC_CTYPE, NiL)) != matchstate.locale)

	{

		matchstate.locale = s;

		flushcache();

	}

	/*

	 * check if the pattern is in the cache

	 */

	for (i = 0; i < sizeof(key) && pattern[i]; i++)

		((char*)&key)[i] = pattern[i];

	for (; i < sizeof(key); i++)

		((char*)&key)[i] = 0;

	empty = unused = -1;

	old = 0;

	for (i = matchstate.size; i--;)

		if (!matchstate.cache[i])

			empty = i;

		else if (!matchstate.cache[i]->keep)

			unused = i;

		else if (*(Key_t*)matchstate.cache[i]->pattern == key && !strcmp(matchstate.cache[i]->pattern, pattern) && matchstate.cache[i]->reflags == reflags)

			break;

		else if (!matchstate.cache[old] || matchstate.cache[old]->serial > matchstate.cache[i]->serial)

			old = i;

	if (i < 0)

	{

		if (unused < 0)

		{

			if (empty < 0)

				unused = old;

			else

				unused = empty;

		}

		if (!(cp = matchstate.cache[unused]) && !(cp = matchstate.cache[unused] = newof(0, Cache_t, 1, 0)))

		{

			if (status)

				*status = REG_ESPACE;

			return 0;

		}

		if (cp->keep)

		{

			cp->keep = 0;

			regfree(&cp->re);

		}

		if ((i = strlen(pattern) + 1) > cp->size)

		{

			cp->size = roundof(i, ROUND);

			if (!(cp->pattern = newof(cp->pattern, char, cp->size, 0)))

			{

				if (status)

					*status = REG_ESPACE;

				return 0;

			}

		}

		strcpy(cp->pattern, pattern);

		while (++i < sizeof(Key_t))

			cp->pattern[i] = 0;

		pattern = (const char*)cp->pattern;

		if (i = regcomp(&cp->re, pattern, reflags))

		{

			if (status)

				*status = i;

			return 0;

		}

		cp->keep = 1;

		cp->reflags = reflags;

	}

	else

		cp = matchstate.cache[i];

	cp->serial = ++matchstate.serial;

	if (status)

		*status = 0;

	return &cp->re;

}