WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/libiberty/regex.c

Rev	Author	Line No.	Line
5191	serge	1	/* Extended regular expression matching and search library,
		2	version 0.12.
		3	(Implements POSIX draft P1003.2/D11.2, except for some of the
		4	internationalization features.)
		5
		6	Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
		7	2002, 2005, 2010, 2013 Free Software Foundation, Inc.
		8	This file is part of the GNU C Library.
		9
		10	The GNU C Library is free software; you can redistribute it and/or
		11	modify it under the terms of the GNU Lesser General Public
		12	License as published by the Free Software Foundation; either
		13	version 2.1 of the License, or (at your option) any later version.
		14
		15	The GNU C Library is distributed in the hope that it will be useful,
		16	but WITHOUT ANY WARRANTY; without even the implied warranty of
		17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		18	Lesser General Public License for more details.
		19
		20	You should have received a copy of the GNU Lesser General Public
		21	License along with the GNU C Library; if not, write to the Free
		22	Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
		23	02110-1301 USA. */
		24
		25	/* This file has been modified for usage in libiberty. It includes "xregex.h"
		26	instead of . The "xregex.h" header file renames all external
		27	routines with an "x" prefix so they do not collide with the native regex
		28	routines or with other components regex routines. */
		29	/* AIX requires this to be the first thing in the file. */
		30	#if defined _AIX && !defined __GNUC__ && !defined REGEX_MALLOC
		31	#pragma alloca
		32	#endif
		33
		34	#undef _GNU_SOURCE
		35	#define _GNU_SOURCE
		36
		37	#ifndef INSIDE_RECURSION
		38	# ifdef HAVE_CONFIG_H
		39	# include
		40	# endif
		41	#endif
		42
		43	#include
		44
		45	#ifndef INSIDE_RECURSION
		46
		47	# if defined STDC_HEADERS && !defined emacs
		48	# include
		49	# define PTR_INT_TYPE ptrdiff_t
		50	# else
		51	/* We need this for `regex.h', and perhaps for the Emacs include files. */
		52	# include
		53	# define PTR_INT_TYPE long
		54	# endif
		55
		56	# define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)
		57
		58	/* For platform which support the ISO C amendement 1 functionality we
		59	support user defined character classes. */
		60	# if defined _LIBC \|\| WIDE_CHAR_SUPPORT
		61	/* Solaris 2.5 has a bug: must be included before . */
		62	# include
		63	# include
		64	# endif
		65
		66	# ifdef _LIBC
		67	/* We have to keep the namespace clean. */
		68	# define regfree(preg) __regfree (preg)
		69	# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
		70	# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
		71	# define regerror(errcode, preg, errbuf, errbuf_size) \
		72	__regerror(errcode, preg, errbuf, errbuf_size)
		73	# define re_set_registers(bu, re, nu, st, en) \
		74	__re_set_registers (bu, re, nu, st, en)
		75	# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
		76	__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
		77	# define re_match(bufp, string, size, pos, regs) \
		78	__re_match (bufp, string, size, pos, regs)
		79	# define re_search(bufp, string, size, startpos, range, regs) \
		80	__re_search (bufp, string, size, startpos, range, regs)
		81	# define re_compile_pattern(pattern, length, bufp) \
		82	__re_compile_pattern (pattern, length, bufp)
		83	# define re_set_syntax(syntax) __re_set_syntax (syntax)
		84	# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
		85	__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
		86	# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
		87
		88	# define btowc __btowc
		89
		90	/* We are also using some library internals. */
		91	# include
		92	# include
		93	# include
		94	# include
		95	# endif
		96
		97	/* This is for other GNU distributions with internationalized messages. */
		98	# if (HAVE_LIBINTL_H && ENABLE_NLS) \|\| defined _LIBC
		99	# include
		100	# ifdef _LIBC
		101	# undef gettext
		102	# define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES)
		103	# endif
		104	# else
		105	# define gettext(msgid) (msgid)
		106	# endif
		107
		108	# ifndef gettext_noop
		109	/* This define is so xgettext can find the internationalizable
		110	strings. */
		111	# define gettext_noop(String) String
		112	# endif
		113
		114	/* The `emacs' switch turns on certain matching commands
		115	that make sense only in Emacs. */
		116	# ifdef emacs
		117
		118	# include "lisp.h"
		119	# include "buffer.h"
		120	# include "syntax.h"
		121
		122	# else /* not emacs */
		123
		124	/* If we are not linking with Emacs proper,
		125	we can't use the relocating allocator
		126	even if config.h says that we can. */
		127	# undef REL_ALLOC
		128
		129	# if defined STDC_HEADERS \|\| defined _LIBC
		130	# include
		131	# else
		132	char *malloc ();
		133	char *realloc ();
		134	# endif
		135
		136	/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
		137	If nothing else has been done, use the method below. */
		138	# ifdef INHIBIT_STRING_HEADER
		139	# if !(defined HAVE_BZERO && defined HAVE_BCOPY)
		140	# if !defined bzero && !defined bcopy
		141	# undef INHIBIT_STRING_HEADER
		142	# endif
		143	# endif
		144	# endif
		145
		146	/* This is the normal way of making sure we have a bcopy and a bzero.
		147	This is used in most programs--a few other programs avoid this
		148	by defining INHIBIT_STRING_HEADER. */
		149	# ifndef INHIBIT_STRING_HEADER
		150	# if defined HAVE_STRING_H \|\| defined STDC_HEADERS \|\| defined _LIBC
		151	# include
		152	# ifndef bzero
		153	# ifndef _LIBC
6324	serge	154	# define bzero(s, n) ((void) memset (s, '\0', n))
5191	serge	155	# else
		156	# define bzero(s, n) __bzero (s, n)
		157	# endif
		158	# endif
		159	# else
		160	# include
		161	# ifndef memcmp
		162	# define memcmp(s1, s2, n) bcmp (s1, s2, n)
		163	# endif
		164	# ifndef memcpy
		165	# define memcpy(d, s, n) (bcopy (s, d, n), (d))
		166	# endif
		167	# endif
		168	# endif
		169
		170	/* Define the syntax stuff for \<, \>, etc. */
		171
		172	/* This must be nonzero for the wordchar and notwordchar pattern
		173	commands in re_match_2. */
		174	# ifndef Sword
		175	# define Sword 1
		176	# endif
		177
		178	# ifdef SWITCH_ENUM_BUG
		179	# define SWITCH_ENUM_CAST(x) ((int)(x))
		180	# else
		181	# define SWITCH_ENUM_CAST(x) (x)
		182	# endif
		183
		184	# endif /* not emacs */
		185
		186	# if defined _LIBC \|\| HAVE_LIMITS_H
		187	# include
		188	# endif
		189
		190	# ifndef MB_LEN_MAX
		191	# define MB_LEN_MAX 1
		192	# endif
		193
		194	/* Get the interface, including the syntax bits. */
		195	# include "xregex.h" /* change for libiberty */
		196
		197	/* isalpha etc. are used for the character classes. */
		198	# include
		199
		200	/* Jim Meyering writes:
		201
		202	"... Some ctype macros are valid only for character codes that
		203	isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
		204	using /bin/cc or gcc but without giving an ansi option). So, all
		205	ctype uses should be through macros like ISPRINT... If
		206	STDC_HEADERS is defined, then autoconf has verified that the ctype
		207	macros don't need to be guarded with references to isascii. ...
		208	Defining isascii to 1 should let any compiler worth its salt
		209	eliminate the && through constant folding."
		210	Solaris defines some of these symbols so we must undefine them first. */
		211
		212	# undef ISASCII
		213	# if defined STDC_HEADERS \|\| (!defined isascii && !defined HAVE_ISASCII)
		214	# define ISASCII(c) 1
		215	# else
		216	# define ISASCII(c) isascii(c)
		217	# endif
		218
		219	# ifdef isblank
		220	# define ISBLANK(c) (ISASCII (c) && isblank (c))
		221	# else
		222	# define ISBLANK(c) ((c) == ' ' \|\| (c) == '\t')
		223	# endif
		224	# ifdef isgraph
		225	# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
		226	# else
		227	# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
		228	# endif
		229
		230	# undef ISPRINT
		231	# define ISPRINT(c) (ISASCII (c) && isprint (c))
		232	# define ISDIGIT(c) (ISASCII (c) && isdigit (c))
		233	# define ISALNUM(c) (ISASCII (c) && isalnum (c))
		234	# define ISALPHA(c) (ISASCII (c) && isalpha (c))
		235	# define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
		236	# define ISLOWER(c) (ISASCII (c) && islower (c))
		237	# define ISPUNCT(c) (ISASCII (c) && ispunct (c))
		238	# define ISSPACE(c) (ISASCII (c) && isspace (c))
		239	# define ISUPPER(c) (ISASCII (c) && isupper (c))
		240	# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
		241
		242	# ifdef _tolower
		243	# define TOLOWER(c) _tolower(c)
		244	# else
		245	# define TOLOWER(c) tolower(c)
		246	# endif
		247
		248	# ifndef NULL
		249	# define NULL (void *)0
		250	# endif
		251
		252	/* We remove any previous definition of `SIGN_EXTEND_CHAR',
		253	since ours (we hope) works properly with all combinations of
		254	machines, compilers, `char' and `unsigned char' argument types.
		255	(Per Bothner suggested the basic approach.) */
		256	# undef SIGN_EXTEND_CHAR
		257	# if __STDC__
		258	# define SIGN_EXTEND_CHAR(c) ((signed char) (c))
		259	# else /* not __STDC__ */
		260	/* As in Harbison and Steele. */
		261	# define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
		262	# endif
		263
		264	# ifndef emacs
		265	/* How many characters in the character set. */
		266	# define CHAR_SET_SIZE 256
		267
		268	# ifdef SYNTAX_TABLE
		269
		270	extern char *re_syntax_table;
		271
		272	# else /* not SYNTAX_TABLE */
		273
		274	static char re_syntax_table[CHAR_SET_SIZE];
		275
		276	static void init_syntax_once (void);
		277
		278	static void
		279	init_syntax_once (void)
		280	{
		281	register int c;
		282	static int done = 0;
		283
		284	if (done)
		285	return;
		286	bzero (re_syntax_table, sizeof re_syntax_table);
		287
		288	for (c = 0; c < CHAR_SET_SIZE; ++c)
		289	if (ISALNUM (c))
		290	re_syntax_table[c] = Sword;
		291
		292	re_syntax_table['_'] = Sword;
		293
		294	done = 1;
		295	}
		296
		297	# endif /* not SYNTAX_TABLE */
		298
		299	# define SYNTAX(c) re_syntax_table[(unsigned char) (c)]
		300
		301	# endif /* emacs */
		302
		303	/* Integer type for pointers. */
		304	# if !defined _LIBC && !defined HAVE_UINTPTR_T
		305	typedef unsigned long int uintptr_t;
		306	# endif
		307
		308	/* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we
		309	use `alloca' instead of `malloc'. This is because using malloc in
		310	re_search* or re_match* could cause memory leaks when C-g is used in
		311	Emacs; also, malloc is slower and causes storage fragmentation. On
		312	the other hand, malloc is more portable, and easier to debug.
		313
		314	Because we sometimes use alloca, some routines have to be macros,
		315	not functions -- `alloca'-allocated space disappears at the end of the
		316	function it is called in. */
		317
		318	# ifdef REGEX_MALLOC
		319
		320	# define REGEX_ALLOCATE malloc
		321	# define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)
		322	# define REGEX_FREE free
		323
		324	# else /* not REGEX_MALLOC */
		325
		326	/* Emacs already defines alloca, sometimes. */
		327	# ifndef alloca
		328
		329	/* Make alloca work the best possible way. */
		330	# ifdef __GNUC__
		331	# define alloca __builtin_alloca
		332	# else /* not __GNUC__ */
		333	# if HAVE_ALLOCA_H
		334	# include
		335	# endif /* HAVE_ALLOCA_H */
		336	# endif /* not __GNUC__ */
		337
		338	# endif /* not alloca */
		339
		340	# define REGEX_ALLOCATE alloca
		341
		342	/* Assumes a `char destination' variable. /
		343	# define REGEX_REALLOCATE(source, osize, nsize) \
		344	(destination = (char *) alloca (nsize), \
		345	memcpy (destination, source, osize))
		346
		347	/* No need to do anything to free, after alloca. */
		348	# define REGEX_FREE(arg) ((void)0) /* Do nothing! But inhibit gcc warning. */
		349
		350	# endif /* not REGEX_MALLOC */
		351
		352	/* Define how to allocate the failure stack. */
		353
		354	# if defined REL_ALLOC && defined REGEX_MALLOC
		355
		356	# define REGEX_ALLOCATE_STACK(size) \
		357	r_alloc (&failure_stack_ptr, (size))
		358	# define REGEX_REALLOCATE_STACK(source, osize, nsize) \
		359	r_re_alloc (&failure_stack_ptr, (nsize))
		360	# define REGEX_FREE_STACK(ptr) \
		361	r_alloc_free (&failure_stack_ptr)
		362
		363	# else /* not using relocating allocator */
		364
		365	# ifdef REGEX_MALLOC
		366
		367	# define REGEX_ALLOCATE_STACK malloc
		368	# define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
		369	# define REGEX_FREE_STACK free
		370
		371	# else /* not REGEX_MALLOC */
		372
		373	# define REGEX_ALLOCATE_STACK alloca
		374
		375	# define REGEX_REALLOCATE_STACK(source, osize, nsize) \
		376	REGEX_REALLOCATE (source, osize, nsize)
		377	/* No need to explicitly free anything. */
		378	# define REGEX_FREE_STACK(arg)
		379
		380	# endif /* not REGEX_MALLOC */
		381	# endif /* not using relocating allocator */
		382
		383
		384	/* True if `size1' is non-NULL and PTR is pointing anywhere inside
		385	`string1' or just past its end. This works if PTR is NULL, which is
		386	a good thing. */
		387	# define FIRST_STRING_P(ptr) \
		388	(size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
		389
		390	/* (Re)Allocate N items of type T using malloc, or fail. */
		391	# define TALLOC(n, t) ((t ) malloc ((n) sizeof (t)))
		392	# define RETALLOC(addr, n, t) ((addr) = (t ) realloc (addr, (n) sizeof (t)))
		393	# define RETALLOC_IF(addr, n, t) \
		394	if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
		395	# define REGEX_TALLOC(n, t) ((t ) REGEX_ALLOCATE ((n) sizeof (t)))
		396
		397	# define BYTEWIDTH 8 /* In bits. */
		398
		399	# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
		400
		401	# undef MAX
		402	# undef MIN
		403	# define MAX(a, b) ((a) > (b) ? (a) : (b))
		404	# define MIN(a, b) ((a) < (b) ? (a) : (b))
		405
		406	typedef char boolean;
		407	# define false 0
		408	# define true 1
		409
		410	static reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
		411	reg_syntax_t syntax,
		412	struct re_pattern_buffer *bufp);
		413
		414	static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
		415	const char *string1, int size1,
		416	const char *string2, int size2,
		417	int pos,
		418	struct re_registers *regs,
		419	int stop);
		420	static int byte_re_search_2 (struct re_pattern_buffer *bufp,
		421	const char *string1, int size1,
		422	const char *string2, int size2,
		423	int startpos, int range,
		424	struct re_registers *regs, int stop);
		425	static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
		426
		427	#ifdef MBS_SUPPORT
		428	static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size,
		429	reg_syntax_t syntax,
		430	struct re_pattern_buffer *bufp);
		431
		432
		433	static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
		434	const char *cstring1, int csize1,
		435	const char *cstring2, int csize2,
		436	int pos,
		437	struct re_registers *regs,
		438	int stop,
		439	wchar_t *string1, int size1,
		440	wchar_t *string2, int size2,
		441	int mbs_offset1, int mbs_offset2);
		442	static int wcs_re_search_2 (struct re_pattern_buffer *bufp,
		443	const char *string1, int size1,
		444	const char *string2, int size2,
		445	int startpos, int range,
		446	struct re_registers *regs, int stop);
		447	static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp);
		448	#endif
		449
		450	/* These are the command codes that appear in compiled regular
		451	expressions. Some opcodes are followed by argument bytes. A
		452	command code can specify any interpretation whatsoever for its
		453	arguments. Zero bytes may appear in the compiled regular expression. */
		454
		455	typedef enum
		456	{
		457	no_op = 0,
		458
		459	/* Succeed right away--no more backtracking. */
		460	succeed,
		461
		462	/* Followed by one byte giving n, then by n literal bytes. */
		463	exactn,
		464
		465	# ifdef MBS_SUPPORT
		466	/* Same as exactn, but contains binary data. */
		467	exactn_bin,
		468	# endif
		469
		470	/* Matches any (more or less) character. */
		471	anychar,
		472
		473	/* Matches any one char belonging to specified set. First
		474	following byte is number of bitmap bytes. Then come bytes
		475	for a bitmap saying which chars are in. Bits in each byte
		476	are ordered low-bit-first. A character is in the set if its
		477	bit is 1. A character too large to have a bit in the map is
		478	automatically not in the set. */
		479	/* ifdef MBS_SUPPORT, following element is length of character
		480	classes, length of collating symbols, length of equivalence
		481	classes, length of character ranges, and length of characters.
		482	Next, character class element, collating symbols elements,
		483	equivalence class elements, range elements, and character
		484	elements follow.
		485	See regex_compile function. */
		486	charset,
		487
		488	/* Same parameters as charset, but match any character that is
		489	not one of those specified. */
		490	charset_not,
		491
		492	/* Start remembering the text that is matched, for storing in a
		493	register. Followed by one byte with the register number, in
		494	the range 0 to one less than the pattern buffer's re_nsub
		495	field. Then followed by one byte with the number of groups
		496	inner to this one. (This last has to be part of the
		497	start_memory only because we need it in the on_failure_jump
		498	of re_match_2.) */
		499	start_memory,
		500
		501	/* Stop remembering the text that is matched and store it in a
		502	memory register. Followed by one byte with the register
		503	number, in the range 0 to one less than `re_nsub' in the
		504	pattern buffer, and one byte with the number of inner groups,
		505	just like `start_memory'. (We need the number of inner
		506	groups here because we don't have any easy way of finding the
		507	corresponding start_memory when we're at a stop_memory.) */
		508	stop_memory,
		509
		510	/* Match a duplicate of something remembered. Followed by one
		511	byte containing the register number. */
		512	duplicate,
		513
		514	/* Fail unless at beginning of line. */
		515	begline,
		516
		517	/* Fail unless at end of line. */
		518	endline,
		519
		520	/* Succeeds if at beginning of buffer (if emacs) or at beginning
		521	of string to be matched (if not). */
		522	begbuf,
		523
		524	/* Analogously, for end of buffer/string. */
		525	endbuf,
		526
		527	/* Followed by two byte relative address to which to jump. */
		528	jump,
		529
		530	/* Same as jump, but marks the end of an alternative. */
		531	jump_past_alt,
		532
		533	/* Followed by two-byte relative address of place to resume at
		534	in case of failure. */
		535	/* ifdef MBS_SUPPORT, the size of address is 1. */
		536	on_failure_jump,
		537
		538	/* Like on_failure_jump, but pushes a placeholder instead of the
		539	current string position when executed. */
		540	on_failure_keep_string_jump,
		541
		542	/* Throw away latest failure point and then jump to following
		543	two-byte relative address. */
		544	/* ifdef MBS_SUPPORT, the size of address is 1. */
		545	pop_failure_jump,
		546
		547	/* Change to pop_failure_jump if know won't have to backtrack to
		548	match; otherwise change to jump. This is used to jump
		549	back to the beginning of a repeat. If what follows this jump
		550	clearly won't match what the repeat does, such that we can be
		551	sure that there is no use backtracking out of repetitions
		552	already matched, then we change it to a pop_failure_jump.
		553	Followed by two-byte address. */
		554	/* ifdef MBS_SUPPORT, the size of address is 1. */
		555	maybe_pop_jump,
		556
		557	/* Jump to following two-byte address, and push a dummy failure
		558	point. This failure point will be thrown away if an attempt
		559	is made to use it for a failure. A `+' construct makes this
		560	before the first repeat. Also used as an intermediary kind
		561	of jump when compiling an alternative. */
		562	/* ifdef MBS_SUPPORT, the size of address is 1. */
		563	dummy_failure_jump,
		564
		565	/* Push a dummy failure point and continue. Used at the end of
		566	alternatives. */
		567	push_dummy_failure,
		568
		569	/* Followed by two-byte relative address and two-byte number n.
		570	After matching N times, jump to the address upon failure. */
		571	/* ifdef MBS_SUPPORT, the size of address is 1. */
		572	succeed_n,
		573
		574	/* Followed by two-byte relative address, and two-byte number n.
		575	Jump to the address N times, then fail. */
		576	/* ifdef MBS_SUPPORT, the size of address is 1. */
		577	jump_n,
		578
		579	/* Set the following two-byte relative address to the
		580	subsequent two-byte number. The address includes the two
		581	bytes of number. */
		582	/* ifdef MBS_SUPPORT, the size of address is 1. */
		583	set_number_at,
		584
		585	wordchar, /* Matches any word-constituent character. */
		586	notwordchar, /* Matches any char that is not a word-constituent. */
		587
		588	wordbeg, /* Succeeds if at word beginning. */
		589	wordend, /* Succeeds if at word end. */
		590
		591	wordbound, /* Succeeds if at a word boundary. */
		592	notwordbound /* Succeeds if not at a word boundary. */
		593
		594	# ifdef emacs
		595	,before_dot, /* Succeeds if before point. */
		596	at_dot, /* Succeeds if at point. */
		597	after_dot, /* Succeeds if after point. */
		598
		599	/* Matches any character whose syntax is specified. Followed by
		600	a byte which contains a syntax code, e.g., Sword. */
		601	syntaxspec,
		602
		603	/* Matches any character whose syntax is not that specified. */
		604	notsyntaxspec
		605	# endif /* emacs */
		606	} re_opcode_t;
		607	#endif /* not INSIDE_RECURSION */
		608
		609
		610	#ifdef BYTE
		611	# define CHAR_T char
		612	# define UCHAR_T unsigned char
		613	# define COMPILED_BUFFER_VAR bufp->buffer
		614	# define OFFSET_ADDRESS_SIZE 2
		615	# define PREFIX(name) byte_##name
		616	# define ARG_PREFIX(name) name
		617	# define PUT_CHAR(c) putchar (c)
		618	#else
		619	# ifdef WCHAR
		620	# define CHAR_T wchar_t
		621	# define UCHAR_T wchar_t
		622	# define COMPILED_BUFFER_VAR wc_buffer
		623	# define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */
		624	# define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1)
		625	# define PREFIX(name) wcs_##name
		626	# define ARG_PREFIX(name) c##name
		627	/* Should we use wide stream?? */
		628	# define PUT_CHAR(c) printf ("%C", c);
		629	# define TRUE 1
		630	# define FALSE 0
		631	# else
		632	# ifdef MBS_SUPPORT
		633	# define WCHAR
		634	# define INSIDE_RECURSION
		635	# include "regex.c"
		636	# undef INSIDE_RECURSION
		637	# endif
		638	# define BYTE
		639	# define INSIDE_RECURSION
		640	# include "regex.c"
		641	# undef INSIDE_RECURSION
		642	# endif
		643	#endif
		644
		645	#ifdef INSIDE_RECURSION
		646	/* Common operations on the compiled pattern. */
		647
		648	/* Store NUMBER in two contiguous bytes starting at DESTINATION. */
		649	/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
		650
		651	# ifdef WCHAR
		652	# define STORE_NUMBER(destination, number) \
		653	do { \
		654	*(destination) = (UCHAR_T)(number); \
		655	} while (0)
		656	# else /* BYTE */
		657	# define STORE_NUMBER(destination, number) \
		658	do { \
		659	(destination)[0] = (number) & 0377; \
		660	(destination)[1] = (number) >> 8; \
		661	} while (0)
		662	# endif /* WCHAR */
		663
		664	/* Same as STORE_NUMBER, except increment DESTINATION to
		665	the byte after where the number is stored. Therefore, DESTINATION
		666	must be an lvalue. */
		667	/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
		668
		669	# define STORE_NUMBER_AND_INCR(destination, number) \
		670	do { \
		671	STORE_NUMBER (destination, number); \
		672	(destination) += OFFSET_ADDRESS_SIZE; \
		673	} while (0)
		674
		675	/* Put into DESTINATION a number stored in two contiguous bytes starting
		676	at SOURCE. */
		677	/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
		678
		679	# ifdef WCHAR
		680	# define EXTRACT_NUMBER(destination, source) \
		681	do { \
		682	(destination) = *(source); \
		683	} while (0)
		684	# else /* BYTE */
		685	# define EXTRACT_NUMBER(destination, source) \
		686	do { \
		687	(destination) = *(source) & 0377; \
		688	(destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \
		689	} while (0)
		690	# endif
		691
		692	# ifdef DEBUG
		693	static void PREFIX(extract_number) (int dest, UCHAR_T source);
		694	static void
		695	PREFIX(extract_number) (int dest, UCHAR_T source)
		696	{
		697	# ifdef WCHAR
		698	dest = source;
		699	# else /* BYTE */
		700	int temp = SIGN_EXTEND_CHAR (*(source + 1));
		701	dest = source & 0377;
		702	*dest += temp << 8;
		703	# endif
		704	}
		705
		706	# ifndef EXTRACT_MACROS /* To debug the macros. */
		707	# undef EXTRACT_NUMBER
		708	# define EXTRACT_NUMBER(dest, src) PREFIX(extract_number) (&dest, src)
		709	# endif /* not EXTRACT_MACROS */
		710
		711	# endif /* DEBUG */
		712
		713	/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
		714	SOURCE must be an lvalue. */
		715
		716	# define EXTRACT_NUMBER_AND_INCR(destination, source) \
		717	do { \
		718	EXTRACT_NUMBER (destination, source); \
		719	(source) += OFFSET_ADDRESS_SIZE; \
		720	} while (0)
		721
		722	# ifdef DEBUG
		723	static void PREFIX(extract_number_and_incr) (int *destination,
		724	UCHAR_T **source);
		725	static void
		726	PREFIX(extract_number_and_incr) (int destination, UCHAR_T *source)
		727	{
		728	PREFIX(extract_number) (destination, *source);
		729	*source += OFFSET_ADDRESS_SIZE;
		730	}
		731
		732	# ifndef EXTRACT_MACROS
		733	# undef EXTRACT_NUMBER_AND_INCR
		734	# define EXTRACT_NUMBER_AND_INCR(dest, src) \
		735	PREFIX(extract_number_and_incr) (&dest, &src)
		736	# endif /* not EXTRACT_MACROS */
		737
		738	# endif /* DEBUG */
		739
		740
		741
		742	/* If DEBUG is defined, Regex prints many voluminous messages about what
		743	it is doing (if the variable `debug' is nonzero). If linked with the
		744	main program in `iregex.c', you can enter patterns and strings
		745	interactively. And if linked with the main program in `main.c' and
		746	the other test files, you can run the already-written tests. */
		747
		748	# ifdef DEBUG
		749
		750	# ifndef DEFINED_ONCE
		751
		752	/* We use standard I/O for debugging. */
		753	# include
		754
		755	/* It is useful to test things that ``must'' be true when debugging. */
		756	# include
		757
		758	static int debug;
		759
		760	# define DEBUG_STATEMENT(e) e
		761	# define DEBUG_PRINT1(x) if (debug) printf (x)
		762	# define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)
		763	# define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)
		764	# define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
		765	# endif /* not DEFINED_ONCE */
		766
		767	# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \
		768	if (debug) PREFIX(print_partial_compiled_pattern) (s, e)
		769	# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \
		770	if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2)
		771
		772
		773	/* Print the fastmap in human-readable form. */
		774
		775	# ifndef DEFINED_ONCE
		776	void
		777	print_fastmap (char *fastmap)
		778	{
		779	unsigned was_a_range = 0;
		780	unsigned i = 0;
		781
		782	while (i < (1 << BYTEWIDTH))
		783	{
		784	if (fastmap[i++])
		785	{
		786	was_a_range = 0;
		787	putchar (i - 1);
		788	while (i < (1 << BYTEWIDTH) && fastmap[i])
		789	{
		790	was_a_range = 1;
		791	i++;
		792	}
		793	if (was_a_range)
		794	{
		795	printf ("-");
		796	putchar (i - 1);
		797	}
		798	}
		799	}
		800	putchar ('\n');
		801	}
		802	# endif /* not DEFINED_ONCE */
		803
		804
		805	/* Print a compiled pattern string in human-readable form, starting at
		806	the START pointer into it and ending just before the pointer END. */
		807
		808	void
		809	PREFIX(print_partial_compiled_pattern) (UCHAR_T start, UCHAR_T end)
		810	{
		811	int mcnt, mcnt2;
		812	UCHAR_T *p1;
		813	UCHAR_T *p = start;
		814	UCHAR_T *pend = end;
		815
		816	if (start == NULL)
		817	{
		818	printf ("(null)\n");
		819	return;
		820	}
		821
		822	/* Loop over pattern commands. */
		823	while (p < pend)
		824	{
		825	# ifdef _LIBC
		826	printf ("%td:\t", p - start);
		827	# else
		828	printf ("%ld:\t", (long int) (p - start));
		829	# endif
		830
		831	switch ((re_opcode_t) *p++)
		832	{
		833	case no_op:
		834	printf ("/no_op");
		835	break;
		836
		837	case exactn:
		838	mcnt = *p++;
		839	printf ("/exactn/%d", mcnt);
		840	do
		841	{
		842	putchar ('/');
		843	PUT_CHAR (*p++);
		844	}
		845	while (--mcnt);
		846	break;
		847
		848	# ifdef MBS_SUPPORT
		849	case exactn_bin:
		850	mcnt = *p++;
		851	printf ("/exactn_bin/%d", mcnt);
		852	do
		853	{
		854	printf("/%lx", (long int) *p++);
		855	}
		856	while (--mcnt);
		857	break;
		858	# endif /* MBS_SUPPORT */
		859
		860	case start_memory:
		861	mcnt = *p++;
		862	printf ("/start_memory/%d/%ld", mcnt, (long int) *p++);
		863	break;
		864
		865	case stop_memory:
		866	mcnt = *p++;
		867	printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++);
		868	break;
		869
		870	case duplicate:
		871	printf ("/duplicate/%ld", (long int) *p++);
		872	break;
		873
		874	case anychar:
		875	printf ("/anychar");
		876	break;
		877
		878	case charset:
		879	case charset_not:
		880	{
		881	# ifdef WCHAR
		882	int i, length;
		883	wchar_t *workp = p;
		884	printf ("/charset [%s",
		885	(re_opcode_t) *(workp - 1) == charset_not ? "^" : "");
		886	p += 5;
		887	length = workp++; / the length of char_classes */
		888	for (i=0 ; i
		889	printf("[:%lx:]", (long int) *p++);
		890	length = workp++; / the length of collating_symbol */
		891	for (i=0 ; i
		892	{
		893	printf("[.");
		894	while(*p != 0)
		895	PUT_CHAR((i++,*p++));
		896	i++,p++;
		897	printf(".]");
		898	}
		899	length = workp++; / the length of equivalence_class */
		900	for (i=0 ; i
		901	{
		902	printf("[=");
		903	while(*p != 0)
		904	PUT_CHAR((i++,*p++));
		905	i++,p++;
		906	printf("=]");
		907	}
		908	length = workp++; / the length of char_range */
		909	for (i=0 ; i
		910	{
		911	wchar_t range_start = *p++;
		912	wchar_t range_end = *p++;
		913	printf("%C-%C", range_start, range_end);
		914	}
		915	length = workp++; / the length of char */
		916	for (i=0 ; i
		917	printf("%C", *p++);
		918	putchar (']');
		919	# else
		920	register int c, last = -100;
		921	register int in_range = 0;
		922
		923	printf ("/charset [%s",
		924	(re_opcode_t) *(p - 1) == charset_not ? "^" : "");
		925
		926	assert (p + *p < pend);
		927
		928	for (c = 0; c < 256; c++)
		929	if (c / 8 < *p
		930	&& (p[1 + (c/8)] & (1 << (c % 8))))
		931	{
		932	/* Are we starting a range? */
		933	if (last + 1 == c && ! in_range)
		934	{
		935	putchar ('-');
		936	in_range = 1;
		937	}
		938	/* Have we broken a range? */
		939	else if (last + 1 != c && in_range)
		940	{
		941	putchar (last);
		942	in_range = 0;
		943	}
		944
		945	if (! in_range)
		946	putchar (c);
		947
		948	last = c;
		949	}
		950
		951	if (in_range)
		952	putchar (last);
		953
		954	putchar (']');
		955
		956	p += 1 + *p;
		957	# endif /* WCHAR */
		958	}
		959	break;
		960
		961	case begline:
		962	printf ("/begline");
		963	break;
		964
		965	case endline:
		966	printf ("/endline");
		967	break;
		968
		969	case on_failure_jump:
		970	PREFIX(extract_number_and_incr) (&mcnt, &p);
		971	# ifdef _LIBC
		972	printf ("/on_failure_jump to %td", p + mcnt - start);
		973	# else
		974	printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start));
		975	# endif
		976	break;
		977
		978	case on_failure_keep_string_jump:
		979	PREFIX(extract_number_and_incr) (&mcnt, &p);
		980	# ifdef _LIBC
		981	printf ("/on_failure_keep_string_jump to %td", p + mcnt - start);
		982	# else
		983	printf ("/on_failure_keep_string_jump to %ld",
		984	(long int) (p + mcnt - start));
		985	# endif
		986	break;
		987
		988	case dummy_failure_jump:
		989	PREFIX(extract_number_and_incr) (&mcnt, &p);
		990	# ifdef _LIBC
		991	printf ("/dummy_failure_jump to %td", p + mcnt - start);
		992	# else
		993	printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start));
		994	# endif
		995	break;
		996
		997	case push_dummy_failure:
		998	printf ("/push_dummy_failure");
		999	break;
		1000
		1001	case maybe_pop_jump:
		1002	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1003	# ifdef _LIBC
		1004	printf ("/maybe_pop_jump to %td", p + mcnt - start);
		1005	# else
		1006	printf ("/maybe_pop_jump to %ld", (long int) (p + mcnt - start));
		1007	# endif
		1008	break;
		1009
		1010	case pop_failure_jump:
		1011	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1012	# ifdef _LIBC
		1013	printf ("/pop_failure_jump to %td", p + mcnt - start);
		1014	# else
		1015	printf ("/pop_failure_jump to %ld", (long int) (p + mcnt - start));
		1016	# endif
		1017	break;
		1018
		1019	case jump_past_alt:
		1020	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1021	# ifdef _LIBC
		1022	printf ("/jump_past_alt to %td", p + mcnt - start);
		1023	# else
		1024	printf ("/jump_past_alt to %ld", (long int) (p + mcnt - start));
		1025	# endif
		1026	break;
		1027
		1028	case jump:
		1029	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1030	# ifdef _LIBC
		1031	printf ("/jump to %td", p + mcnt - start);
		1032	# else
		1033	printf ("/jump to %ld", (long int) (p + mcnt - start));
		1034	# endif
		1035	break;
		1036
		1037	case succeed_n:
		1038	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1039	p1 = p + mcnt;
		1040	PREFIX(extract_number_and_incr) (&mcnt2, &p);
		1041	# ifdef _LIBC
		1042	printf ("/succeed_n to %td, %d times", p1 - start, mcnt2);
		1043	# else
		1044	printf ("/succeed_n to %ld, %d times",
		1045	(long int) (p1 - start), mcnt2);
		1046	# endif
		1047	break;
		1048
		1049	case jump_n:
		1050	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1051	p1 = p + mcnt;
		1052	PREFIX(extract_number_and_incr) (&mcnt2, &p);
		1053	printf ("/jump_n to %d, %d times", p1 - start, mcnt2);
		1054	break;
		1055
		1056	case set_number_at:
		1057	PREFIX(extract_number_and_incr) (&mcnt, &p);
		1058	p1 = p + mcnt;
		1059	PREFIX(extract_number_and_incr) (&mcnt2, &p);
		1060	# ifdef _LIBC
		1061	printf ("/set_number_at location %td to %d", p1 - start, mcnt2);
		1062	# else
		1063	printf ("/set_number_at location %ld to %d",
		1064	(long int) (p1 - start), mcnt2);
		1065	# endif
		1066	break;
		1067
		1068	case wordbound:
		1069	printf ("/wordbound");
		1070	break;
		1071
		1072	case notwordbound:
		1073	printf ("/notwordbound");
		1074	break;
		1075
		1076	case wordbeg:
		1077	printf ("/wordbeg");
		1078	break;
		1079
		1080	case wordend:
		1081	printf ("/wordend");
		1082	break;
		1083
		1084	# ifdef emacs
		1085	case before_dot:
		1086	printf ("/before_dot");
		1087	break;
		1088
		1089	case at_dot:
		1090	printf ("/at_dot");
		1091	break;
		1092
		1093	case after_dot:
		1094	printf ("/after_dot");
		1095	break;
		1096
		1097	case syntaxspec:
		1098	printf ("/syntaxspec");
		1099	mcnt = *p++;
		1100	printf ("/%d", mcnt);
		1101	break;
		1102
		1103	case notsyntaxspec:
		1104	printf ("/notsyntaxspec");
		1105	mcnt = *p++;
		1106	printf ("/%d", mcnt);
		1107	break;
		1108	# endif /* emacs */
		1109
		1110	case wordchar:
		1111	printf ("/wordchar");
		1112	break;
		1113
		1114	case notwordchar:
		1115	printf ("/notwordchar");
		1116	break;
		1117
		1118	case begbuf:
		1119	printf ("/begbuf");
		1120	break;
		1121
		1122	case endbuf:
		1123	printf ("/endbuf");
		1124	break;
		1125
		1126	default:
		1127	printf ("?%ld", (long int) *(p-1));
		1128	}
		1129
		1130	putchar ('\n');
		1131	}
		1132
		1133	# ifdef _LIBC
		1134	printf ("%td:\tend of pattern.\n", p - start);
		1135	# else
		1136	printf ("%ld:\tend of pattern.\n", (long int) (p - start));
		1137	# endif
		1138	}
		1139
		1140
		1141	void
		1142	PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp)
		1143	{
		1144	UCHAR_T buffer = (UCHAR_T) bufp->buffer;
		1145
		1146	PREFIX(print_partial_compiled_pattern) (buffer, buffer
		1147	+ bufp->used / sizeof(UCHAR_T));
		1148	printf ("%ld bytes used/%ld bytes allocated.\n",
		1149	bufp->used, bufp->allocated);
		1150
		1151	if (bufp->fastmap_accurate && bufp->fastmap)
		1152	{
		1153	printf ("fastmap: ");
		1154	print_fastmap (bufp->fastmap);
		1155	}
		1156
		1157	# ifdef _LIBC
		1158	printf ("re_nsub: %Zd\t", bufp->re_nsub);
		1159	# else
		1160	printf ("re_nsub: %ld\t", (long int) bufp->re_nsub);
		1161	# endif
		1162	printf ("regs_alloc: %d\t", bufp->regs_allocated);
		1163	printf ("can_be_null: %d\t", bufp->can_be_null);
		1164	printf ("newline_anchor: %d\n", bufp->newline_anchor);
		1165	printf ("no_sub: %d\t", bufp->no_sub);
		1166	printf ("not_bol: %d\t", bufp->not_bol);
		1167	printf ("not_eol: %d\t", bufp->not_eol);
		1168	printf ("syntax: %lx\n", bufp->syntax);
		1169	/* Perhaps we should print the translate table? */
		1170	}
		1171
		1172
		1173	void
		1174	PREFIX(print_double_string) (const CHAR_T where, const CHAR_T string1,
		1175	int size1, const CHAR_T *string2, int size2)
		1176	{
		1177	int this_char;
		1178
		1179	if (where == NULL)
		1180	printf ("(null)");
		1181	else
		1182	{
		1183	int cnt;
		1184
		1185	if (FIRST_STRING_P (where))
		1186	{
		1187	for (this_char = where - string1; this_char < size1; this_char++)
		1188	PUT_CHAR (string1[this_char]);
		1189
		1190	where = string2;
		1191	}
		1192
		1193	cnt = 0;
		1194	for (this_char = where - string2; this_char < size2; this_char++)
		1195	{
		1196	PUT_CHAR (string2[this_char]);
		1197	if (++cnt > 100)
		1198	{
		1199	fputs ("...", stdout);
		1200	break;
		1201	}
		1202	}
		1203	}
		1204	}
		1205
		1206	# ifndef DEFINED_ONCE
		1207	void
		1208	printchar (int c)
		1209	{
		1210	putc (c, stderr);
		1211	}
		1212	# endif
		1213
		1214	# else /* not DEBUG */
		1215
		1216	# ifndef DEFINED_ONCE
		1217	# undef assert
		1218	# define assert(e)
		1219
		1220	# define DEBUG_STATEMENT(e)
		1221	# define DEBUG_PRINT1(x)
		1222	# define DEBUG_PRINT2(x1, x2)
		1223	# define DEBUG_PRINT3(x1, x2, x3)
		1224	# define DEBUG_PRINT4(x1, x2, x3, x4)
		1225	# endif /* not DEFINED_ONCE */
		1226	# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
		1227	# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
		1228
		1229	# endif /* not DEBUG */
		1230
		1231
		1232
		1233	# ifdef WCHAR
		1234	/* This convert a multibyte string to a wide character string.
		1235	And write their correspondances to offset_buffer(see below)
		1236	and write whether each wchar_t is binary data to is_binary.
		1237	This assume invalid multibyte sequences as binary data.
		1238	We assume offset_buffer and is_binary is already allocated
		1239	enough space. */
		1240
		1241	static size_t convert_mbs_to_wcs (CHAR_T dest, const unsigned char src,
		1242	size_t len, int *offset_buffer,
		1243	char *is_binary);
		1244	static size_t
		1245	convert_mbs_to_wcs (CHAR_T dest, const unsigned charsrc, size_t len,
		1246	int offset_buffer, char is_binary)
		1247	/* It hold correspondances between src(char string) and
		1248	dest(wchar_t string) for optimization.
		1249	e.g. src = "xxxyzz"
		1250	dest = {'X', 'Y', 'Z'}
		1251	(each "xxx", "y" and "zz" represent one multibyte character
		1252	corresponding to 'X', 'Y' and 'Z'.)
		1253	offset_buffer = {0, 0+3("xxx"), 0+3+1("y"), 0+3+1+2("zz")}
		1254	= {0, 3, 4, 6}
		1255	*/
		1256	{
		1257	wchar_t *pdest = dest;
		1258	const unsigned char *psrc = src;
		1259	size_t wc_count = 0;
		1260
		1261	mbstate_t mbs;
		1262	int i, consumed;
		1263	size_t mb_remain = len;
		1264	size_t mb_count = 0;
		1265
		1266	/* Initialize the conversion state. */
		1267	memset (&mbs, 0, sizeof (mbstate_t));
		1268
		1269	offset_buffer[0] = 0;
		1270	for( ; mb_remain > 0 ; ++wc_count, ++pdest, mb_remain -= consumed,
		1271	psrc += consumed)
		1272	{
		1273	#ifdef _LIBC
		1274	consumed = __mbrtowc (pdest, psrc, mb_remain, &mbs);
		1275	#else
		1276	consumed = mbrtowc (pdest, psrc, mb_remain, &mbs);
		1277	#endif
		1278
		1279	if (consumed <= 0)
		1280	/* failed to convert. maybe src contains binary data.
		1281	So we consume 1 byte manualy. */
		1282	{
		1283	pdest = psrc;
		1284	consumed = 1;
		1285	is_binary[wc_count] = TRUE;
		1286	}
		1287	else
		1288	is_binary[wc_count] = FALSE;
		1289	/* In sjis encoding, we use yen sign as escape character in
		1290	place of reverse solidus. So we convert 0x5c(yen sign in
		1291	sjis) to not 0xa5(yen sign in UCS2) but 0x5c(reverse
		1292	solidus in UCS2). */
		1293	if (consumed == 1 && (int) psrc == 0x5c && (int) pdest == 0xa5)
		1294	pdest = (wchar_t) psrc;
		1295
		1296	offset_buffer[wc_count + 1] = mb_count += consumed;
		1297	}
		1298
		1299	/* Fill remain of the buffer with sentinel. */
		1300	for (i = wc_count + 1 ; i <= len ; i++)
		1301	offset_buffer[i] = mb_count + 1;
		1302
		1303	return wc_count;
		1304	}
		1305
		1306	# endif /* WCHAR */
		1307
		1308	#else /* not INSIDE_RECURSION */
		1309
		1310	/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can
		1311	also be assigned to arbitrarily: each pattern buffer stores its own
		1312	syntax, so it can be changed between regex compilations. */
		1313	/* This has no initializer because initialized variables in Emacs
		1314	become read-only after dumping. */
		1315	reg_syntax_t re_syntax_options;
		1316
		1317
		1318	/* Specify the precise syntax of regexps for compilation. This provides
		1319	for compatibility for various utilities which historically have
		1320	different, incompatible syntaxes.
		1321
		1322	The argument SYNTAX is a bit mask comprised of the various bits
		1323	defined in regex.h. We return the old syntax. */
		1324
		1325	reg_syntax_t
		1326	re_set_syntax (reg_syntax_t syntax)
		1327	{
		1328	reg_syntax_t ret = re_syntax_options;
		1329
		1330	re_syntax_options = syntax;
		1331	# ifdef DEBUG
		1332	if (syntax & RE_DEBUG)
		1333	debug = 1;
		1334	else if (debug) /* was on but now is not */
		1335	debug = 0;
		1336	# endif /* DEBUG */
		1337	return ret;
		1338	}
		1339	# ifdef _LIBC
		1340	weak_alias (__re_set_syntax, re_set_syntax)
		1341	# endif
		1342
		1343	/* This table gives an error message for each of the error codes listed
		1344	in regex.h. Obviously the order here has to be same as there.
		1345	POSIX doesn't require that we do anything for REG_NOERROR,
		1346	but why not be nice? */
		1347
		1348	static const char *re_error_msgid[] =
		1349	{
		1350	gettext_noop ("Success"), /* REG_NOERROR */
		1351	gettext_noop ("No match"), /* REG_NOMATCH */
		1352	gettext_noop ("Invalid regular expression"), /* REG_BADPAT */
		1353	gettext_noop ("Invalid collation character"), /* REG_ECOLLATE */
		1354	gettext_noop ("Invalid character class name"), /* REG_ECTYPE */
		1355	gettext_noop ("Trailing backslash"), /* REG_EESCAPE */
		1356	gettext_noop ("Invalid back reference"), /* REG_ESUBREG */
		1357	gettext_noop ("Unmatched [ or [^"), /* REG_EBRACK */
		1358	gettext_noop ("Unmatched ( or \\("), /* REG_EPAREN */
		1359	gettext_noop ("Unmatched \\{"), /* REG_EBRACE */
		1360	gettext_noop ("Invalid content of \\{\\}"), /* REG_BADBR */
		1361	gettext_noop ("Invalid range end"), /* REG_ERANGE */
		1362	gettext_noop ("Memory exhausted"), /* REG_ESPACE */
		1363	gettext_noop ("Invalid preceding regular expression"), /* REG_BADRPT */
		1364	gettext_noop ("Premature end of regular expression"), /* REG_EEND */
		1365	gettext_noop ("Regular expression too big"), /* REG_ESIZE */
		1366	gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */
		1367	};
		1368
		1369	#endif /* INSIDE_RECURSION */
		1370
		1371	#ifndef DEFINED_ONCE
		1372	/* Avoiding alloca during matching, to placate r_alloc. */
		1373
		1374	/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
		1375	searching and matching functions should not call alloca. On some
		1376	systems, alloca is implemented in terms of malloc, and if we're
		1377	using the relocating allocator routines, then malloc could cause a
		1378	relocation, which might (if the strings being searched are in the
		1379	ralloc heap) shift the data out from underneath the regexp
		1380	routines.
		1381
		1382	Here's another reason to avoid allocation: Emacs
		1383	processes input from X in a signal handler; processing X input may
		1384	call malloc; if input arrives while a matching routine is calling
		1385	malloc, then we're scrod. But Emacs can't just block input while
		1386	calling matching routines; then we don't notice interrupts when
		1387	they come in. So, Emacs blocks input around all regexp calls
		1388	except the matching calls, which it leaves unprotected, in the
		1389	faith that they will not malloc. */
		1390
		1391	/* Normally, this is fine. */
		1392	# define MATCH_MAY_ALLOCATE
		1393
		1394	/* When using GNU C, we are not REALLY using the C alloca, no matter
		1395	what config.h may say. So don't take precautions for it. */
		1396	# ifdef __GNUC__
		1397	# undef C_ALLOCA
		1398	# endif
		1399
		1400	/* The match routines may not allocate if (1) they would do it with malloc
		1401	and (2) it's not safe for them to use malloc.
		1402	Note that if REL_ALLOC is defined, matching would not use malloc for the
		1403	failure stack, but we would still use it for the register vectors;
		1404	so REL_ALLOC should not affect this. */
		1405	# if (defined C_ALLOCA \|\| defined REGEX_MALLOC) && defined emacs
		1406	# undef MATCH_MAY_ALLOCATE
		1407	# endif
		1408	#endif /* not DEFINED_ONCE */
		1409
		1410	#ifdef INSIDE_RECURSION
		1411	/* Failure stack declarations and macros; both re_compile_fastmap and
		1412	re_match_2 use a failure stack. These have to be macros because of
		1413	REGEX_ALLOCATE_STACK. */
		1414
		1415
		1416	/* Number of failure points for which to initially allocate space
		1417	when matching. If this number is exceeded, we allocate more
		1418	space, so it is not a hard limit. */
		1419	# ifndef INIT_FAILURE_ALLOC
		1420	# define INIT_FAILURE_ALLOC 5
		1421	# endif
		1422
		1423	/* Roughly the maximum number of failure points on the stack. Would be
		1424	exactly that if always used MAX_FAILURE_ITEMS items each time we failed.
		1425	This is a variable only so users of regex can assign to it; we never
		1426	change it ourselves. */
		1427
		1428	# ifdef INT_IS_16BIT
		1429
		1430	# ifndef DEFINED_ONCE
		1431	# if defined MATCH_MAY_ALLOCATE
		1432	/* 4400 was enough to cause a crash on Alpha OSF/1,
		1433	whose default stack limit is 2mb. */
		1434	long int re_max_failures = 4000;
		1435	# else
		1436	long int re_max_failures = 2000;
		1437	# endif
		1438	# endif
		1439
		1440	union PREFIX(fail_stack_elt)
		1441	{
		1442	UCHAR_T *pointer;
		1443	long int integer;
		1444	};
		1445
		1446	typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
		1447
		1448	typedef struct
		1449	{
		1450	PREFIX(fail_stack_elt_t) *stack;
		1451	unsigned long int size;
		1452	unsigned long int avail; /* Offset of next open position. */
		1453	} PREFIX(fail_stack_type);
		1454
		1455	# else /* not INT_IS_16BIT */
		1456
		1457	# ifndef DEFINED_ONCE
		1458	# if defined MATCH_MAY_ALLOCATE
		1459	/* 4400 was enough to cause a crash on Alpha OSF/1,
		1460	whose default stack limit is 2mb. */
		1461	int re_max_failures = 4000;
		1462	# else
		1463	int re_max_failures = 2000;
		1464	# endif
		1465	# endif
		1466
		1467	union PREFIX(fail_stack_elt)
		1468	{
		1469	UCHAR_T *pointer;
		1470	int integer;
		1471	};
		1472
		1473	typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
		1474
		1475	typedef struct
		1476	{
		1477	PREFIX(fail_stack_elt_t) *stack;
		1478	unsigned size;
		1479	unsigned avail; /* Offset of next open position. */
		1480	} PREFIX(fail_stack_type);
		1481
		1482	# endif /* INT_IS_16BIT */
		1483
		1484	# ifndef DEFINED_ONCE
		1485	# define FAIL_STACK_EMPTY() (fail_stack.avail == 0)
		1486	# define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
		1487	# define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size)
		1488	# endif
		1489
		1490
		1491	/* Define macros to initialize and free the failure stack.
		1492	Do `return -2' if the alloc fails. */
		1493
		1494	# ifdef MATCH_MAY_ALLOCATE
		1495	# define INIT_FAIL_STACK() \
		1496	do { \
		1497	fail_stack.stack = (PREFIX(fail_stack_elt_t) *) \
		1498	REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (PREFIX(fail_stack_elt_t))); \
		1499	\
		1500	if (fail_stack.stack == NULL) \
		1501	return -2; \
		1502	\
		1503	fail_stack.size = INIT_FAILURE_ALLOC; \
		1504	fail_stack.avail = 0; \
		1505	} while (0)
		1506
		1507	# define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack)
		1508	# else
		1509	# define INIT_FAIL_STACK() \
		1510	do { \
		1511	fail_stack.avail = 0; \
		1512	} while (0)
		1513
		1514	# define RESET_FAIL_STACK()
		1515	# endif
		1516
		1517
		1518	/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.
		1519
		1520	Return 1 if succeeds, and 0 if either ran out of memory
		1521	allocating space for it or it was already too large.
		1522
		1523	REGEX_REALLOCATE_STACK requires `destination' be declared. */
		1524
		1525	# define DOUBLE_FAIL_STACK(fail_stack) \
		1526	((fail_stack).size > (unsigned) (re_max_failures * MAX_FAILURE_ITEMS) \
		1527	? 0 \
		1528	: ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *) \
		1529	REGEX_REALLOCATE_STACK ((fail_stack).stack, \
		1530	(fail_stack).size * sizeof (PREFIX(fail_stack_elt_t)), \
		1531	((fail_stack).size << 1) * sizeof (PREFIX(fail_stack_elt_t))),\
		1532	\
		1533	(fail_stack).stack == NULL \
		1534	? 0 \
		1535	: ((fail_stack).size <<= 1, \
		1536	1)))
		1537
		1538
		1539	/* Push pointer POINTER on FAIL_STACK.
		1540	Return 1 if was able to do so and 0 if ran out of memory allocating
		1541	space to do so. */
		1542	# define PUSH_PATTERN_OP(POINTER, FAIL_STACK) \
		1543	((FAIL_STACK_FULL () \
		1544	&& !DOUBLE_FAIL_STACK (FAIL_STACK)) \
		1545	? 0 \
		1546	: ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \
		1547	1))
		1548
		1549	/* Push a pointer value onto the failure stack.
		1550	Assumes the variable `fail_stack'. Probably should only
		1551	be called from within `PUSH_FAILURE_POINT'. */
		1552	# define PUSH_FAILURE_POINTER(item) \
		1553	fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item)
		1554
		1555	/* This pushes an integer-valued item onto the failure stack.
		1556	Assumes the variable `fail_stack'. Probably should only
		1557	be called from within `PUSH_FAILURE_POINT'. */
		1558	# define PUSH_FAILURE_INT(item) \
		1559	fail_stack.stack[fail_stack.avail++].integer = (item)
		1560
		1561	/* Push a fail_stack_elt_t value onto the failure stack.
		1562	Assumes the variable `fail_stack'. Probably should only
		1563	be called from within `PUSH_FAILURE_POINT'. */
		1564	# define PUSH_FAILURE_ELT(item) \
		1565	fail_stack.stack[fail_stack.avail++] = (item)
		1566
		1567	/* These three POP... operations complement the three PUSH... operations.
		1568	All assume that `fail_stack' is nonempty. */
		1569	# define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
		1570	# define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
		1571	# define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
		1572
		1573	/* Used to omit pushing failure point id's when we're not debugging. */
		1574	# ifdef DEBUG
		1575	# define DEBUG_PUSH PUSH_FAILURE_INT
		1576	# define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
		1577	# else
		1578	# define DEBUG_PUSH(item)
		1579	# define DEBUG_POP(item_addr)
		1580	# endif
		1581
		1582
		1583	/* Push the information about the state we will need
		1584	if we ever fail back to it.
		1585
		1586	Requires variables fail_stack, regstart, regend, reg_info, and
		1587	num_regs_pushed be declared. DOUBLE_FAIL_STACK requires `destination'
		1588	be declared.
		1589
		1590	Does `return FAILURE_CODE' if runs out of memory. */
		1591
		1592	# define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \
		1593	do { \
		1594	char *destination; \
		1595	/* Must be int, so when we don't save any registers, the arithmetic \
		1596	of 0 + -1 isn't done as unsigned. */ \
		1597	/* Can't be int, since there is not a shred of a guarantee that int \
		1598	is wide enough to hold a value of something to which pointer can \
		1599	be assigned */ \
		1600	active_reg_t this_reg; \
		1601	\
		1602	DEBUG_STATEMENT (failure_id++); \
		1603	DEBUG_STATEMENT (nfailure_points_pushed++); \
		1604	DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \
		1605	DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\
		1606	DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\
		1607	\
		1608	DEBUG_PRINT2 (" slots needed: %ld\n", NUM_FAILURE_ITEMS); \
		1609	DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \
		1610	\
		1611	/* Ensure we have enough space allocated for what we will push. */ \
		1612	while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \
		1613	{ \
		1614	if (!DOUBLE_FAIL_STACK (fail_stack)) \
		1615	return failure_code; \
		1616	\
		1617	DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \
		1618	(fail_stack).size); \
		1619	DEBUG_PRINT2 (" slots available: %d\n", REMAINING_AVAIL_SLOTS);\
		1620	} \
		1621	\
		1622	/* Push the info, starting with the registers. */ \
		1623	DEBUG_PRINT1 ("\n"); \
		1624	\
		1625	if (1) \
		1626	for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \
		1627	this_reg++) \
		1628	{ \
		1629	DEBUG_PRINT2 (" Pushing reg: %lu\n", this_reg); \
		1630	DEBUG_STATEMENT (num_regs_pushed++); \
		1631	\
		1632	DEBUG_PRINT2 (" start: %p\n", regstart[this_reg]); \
		1633	PUSH_FAILURE_POINTER (regstart[this_reg]); \
		1634	\
		1635	DEBUG_PRINT2 (" end: %p\n", regend[this_reg]); \
		1636	PUSH_FAILURE_POINTER (regend[this_reg]); \
		1637	\
		1638	DEBUG_PRINT2 (" info: %p\n ", \
		1639	reg_info[this_reg].word.pointer); \
		1640	DEBUG_PRINT2 (" match_null=%d", \
		1641	REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \
		1642	DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \
		1643	DEBUG_PRINT2 (" matched_something=%d", \
		1644	MATCHED_SOMETHING (reg_info[this_reg])); \
		1645	DEBUG_PRINT2 (" ever_matched=%d", \
		1646	EVER_MATCHED_SOMETHING (reg_info[this_reg])); \
		1647	DEBUG_PRINT1 ("\n"); \
		1648	PUSH_FAILURE_ELT (reg_info[this_reg].word); \
		1649	} \
		1650	\
		1651	DEBUG_PRINT2 (" Pushing low active reg: %ld\n", lowest_active_reg);\
		1652	PUSH_FAILURE_INT (lowest_active_reg); \
		1653	\
		1654	DEBUG_PRINT2 (" Pushing high active reg: %ld\n", highest_active_reg);\
		1655	PUSH_FAILURE_INT (highest_active_reg); \
		1656	\
		1657	DEBUG_PRINT2 (" Pushing pattern %p:\n", pattern_place); \
		1658	DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \
		1659	PUSH_FAILURE_POINTER (pattern_place); \
		1660	\
		1661	DEBUG_PRINT2 (" Pushing string %p: `", string_place); \
		1662	DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \
		1663	size2); \
		1664	DEBUG_PRINT1 ("'\n"); \
		1665	PUSH_FAILURE_POINTER (string_place); \
		1666	\
		1667	DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \
		1668	DEBUG_PUSH (failure_id); \
		1669	} while (0)
		1670
		1671	# ifndef DEFINED_ONCE
		1672	/* This is the number of items that are pushed and popped on the stack
		1673	for each register. */
		1674	# define NUM_REG_ITEMS 3
		1675
		1676	/* Individual items aside from the registers. */
		1677	# ifdef DEBUG
		1678	# define NUM_NONREG_ITEMS 5 /* Includes failure point id. */
		1679	# else
		1680	# define NUM_NONREG_ITEMS 4
		1681	# endif
		1682
		1683	/* We push at most this many items on the stack. */
		1684	/* We used to use (num_regs - 1), which is the number of registers
		1685	this regexp will save; but that was changed to 5
		1686	to avoid stack overflow for a regexp with lots of parens. */
		1687	# define MAX_FAILURE_ITEMS (5 * NUM_REG_ITEMS + NUM_NONREG_ITEMS)
		1688
		1689	/* We actually push this many items. */
		1690	# define NUM_FAILURE_ITEMS \
		1691	(((0 \
		1692	? 0 : highest_active_reg - lowest_active_reg + 1) \
		1693	* NUM_REG_ITEMS) \
		1694	+ NUM_NONREG_ITEMS)
		1695
		1696	/* How many items can still be added to the stack without overflowing it. */
		1697	# define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)
		1698	# endif /* not DEFINED_ONCE */
		1699
		1700
		1701	/* Pops what PUSH_FAIL_STACK pushes.
		1702
		1703	We restore into the parameters, all of which should be lvalues:
		1704	STR -- the saved data position.
		1705	PAT -- the saved pattern position.
		1706	LOW_REG, HIGH_REG -- the highest and lowest active registers.
		1707	REGSTART, REGEND -- arrays of string positions.
		1708	REG_INFO -- array of information about each subexpression.
		1709
		1710	Also assumes the variables `fail_stack' and (if debugging), `bufp',
		1711	`pend', `string1', `size1', `string2', and `size2'. */
		1712	# define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
		1713	{ \
		1714	DEBUG_STATEMENT (unsigned failure_id;) \
		1715	active_reg_t this_reg; \
		1716	const UCHAR_T *string_temp; \
		1717	\
		1718	assert (!FAIL_STACK_EMPTY ()); \
		1719	\
		1720	/* Remove failure points and point to how many regs pushed. */ \
		1721	DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \
		1722	DEBUG_PRINT2 (" Before pop, next avail: %d\n", fail_stack.avail); \
		1723	DEBUG_PRINT2 (" size: %d\n", fail_stack.size); \
		1724	\
		1725	assert (fail_stack.avail >= NUM_NONREG_ITEMS); \
		1726	\
		1727	DEBUG_POP (&failure_id); \
		1728	DEBUG_PRINT2 (" Popping failure id: %u\n", failure_id); \
		1729	\
		1730	/* If the saved string location is NULL, it came from an \
		1731	on_failure_keep_string_jump opcode, and we want to throw away the \
		1732	saved NULL, thus retaining our current position in the string. */ \
		1733	string_temp = POP_FAILURE_POINTER (); \
		1734	if (string_temp != NULL) \
		1735	str = (const CHAR_T *) string_temp; \
		1736	\
		1737	DEBUG_PRINT2 (" Popping string %p: `", str); \
		1738	DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \
		1739	DEBUG_PRINT1 ("'\n"); \
		1740	\
		1741	pat = (UCHAR_T *) POP_FAILURE_POINTER (); \
		1742	DEBUG_PRINT2 (" Popping pattern %p:\n", pat); \
		1743	DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \
		1744	\
		1745	/* Restore register info. */ \
		1746	high_reg = (active_reg_t) POP_FAILURE_INT (); \
		1747	DEBUG_PRINT2 (" Popping high active reg: %ld\n", high_reg); \
		1748	\
		1749	low_reg = (active_reg_t) POP_FAILURE_INT (); \
		1750	DEBUG_PRINT2 (" Popping low active reg: %ld\n", low_reg); \
		1751	\
		1752	if (1) \
		1753	for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \
		1754	{ \
		1755	DEBUG_PRINT2 (" Popping reg: %ld\n", this_reg); \
		1756	\
		1757	reg_info[this_reg].word = POP_FAILURE_ELT (); \
		1758	DEBUG_PRINT2 (" info: %p\n", \
		1759	reg_info[this_reg].word.pointer); \
		1760	\
		1761	regend[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER (); \
		1762	DEBUG_PRINT2 (" end: %p\n", regend[this_reg]); \
		1763	\
		1764	regstart[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER (); \
		1765	DEBUG_PRINT2 (" start: %p\n", regstart[this_reg]); \
		1766	} \
		1767	else \
		1768	{ \
		1769	for (this_reg = highest_active_reg; this_reg > high_reg; this_reg--) \
		1770	{ \
		1771	reg_info[this_reg].word.integer = 0; \
		1772	regend[this_reg] = 0; \
		1773	regstart[this_reg] = 0; \
		1774	} \
		1775	highest_active_reg = high_reg; \
		1776	} \
		1777	\
		1778	set_regs_matched_done = 0; \
		1779	DEBUG_STATEMENT (nfailure_points_popped++); \
		1780	} /* POP_FAILURE_POINT */
		1781
		1782	/* Structure for per-register (a.k.a. per-group) information.
		1783	Other register information, such as the
		1784	starting and ending positions (which are addresses), and the list of
		1785	inner groups (which is a bits list) are maintained in separate
		1786	variables.
		1787
		1788	We are making a (strictly speaking) nonportable assumption here: that
		1789	the compiler will pack our bit fields into something that fits into
		1790	the type of `word', i.e., is something that fits into one item on the
		1791	failure stack. */
		1792
		1793
		1794	/* Declarations and macros for re_match_2. */
		1795
		1796	typedef union
		1797	{
		1798	PREFIX(fail_stack_elt_t) word;
		1799	struct
		1800	{
		1801	/* This field is one if this group can match the empty string,
		1802	zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */
		1803	# define MATCH_NULL_UNSET_VALUE 3
		1804	unsigned match_null_string_p : 2;
		1805	unsigned is_active : 1;
		1806	unsigned matched_something : 1;
		1807	unsigned ever_matched_something : 1;
		1808	} bits;
		1809	} PREFIX(register_info_type);
		1810
		1811	# ifndef DEFINED_ONCE
		1812	# define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p)
		1813	# define IS_ACTIVE(R) ((R).bits.is_active)
		1814	# define MATCHED_SOMETHING(R) ((R).bits.matched_something)
		1815	# define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something)
		1816
		1817
		1818	/* Call this when have matched a real character; it sets `matched' flags
		1819	for the subexpressions which we are currently inside. Also records
		1820	that those subexprs have matched. */
		1821	# define SET_REGS_MATCHED() \
		1822	do \
		1823	{ \
		1824	if (!set_regs_matched_done) \
		1825	{ \
		1826	active_reg_t r; \
		1827	set_regs_matched_done = 1; \
		1828	for (r = lowest_active_reg; r <= highest_active_reg; r++) \
		1829	{ \
		1830	MATCHED_SOMETHING (reg_info[r]) \
		1831	= EVER_MATCHED_SOMETHING (reg_info[r]) \
		1832	= 1; \
		1833	} \
		1834	} \
		1835	} \
		1836	while (0)
		1837	# endif /* not DEFINED_ONCE */
		1838
		1839	/* Registers are set to a sentinel when they haven't yet matched. */
		1840	static CHAR_T PREFIX(reg_unset_dummy);
		1841	# define REG_UNSET_VALUE (&PREFIX(reg_unset_dummy))
		1842	# define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
		1843
		1844	/* Subroutine declarations and macros for regex_compile. */
		1845	static void PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg);
		1846	static void PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc,
		1847	int arg1, int arg2);
		1848	static void PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc,
		1849	int arg, UCHAR_T *end);
		1850	static void PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc,
		1851	int arg1, int arg2, UCHAR_T *end);
		1852	static boolean PREFIX(at_begline_loc_p) (const CHAR_T *pattern,
		1853	const CHAR_T *p,
		1854	reg_syntax_t syntax);
		1855	static boolean PREFIX(at_endline_loc_p) (const CHAR_T *p,
		1856	const CHAR_T *pend,
		1857	reg_syntax_t syntax);
		1858	# ifdef WCHAR
		1859	static reg_errcode_t wcs_compile_range (CHAR_T range_start,
		1860	const CHAR_T **p_ptr,
		1861	const CHAR_T *pend,
		1862	char *translate,
		1863	reg_syntax_t syntax,
		1864	UCHAR_T *b,
		1865	CHAR_T *char_set);
		1866	static void insert_space (int num, CHAR_T loc, CHAR_T end);
		1867	# else /* BYTE */
		1868	static reg_errcode_t byte_compile_range (unsigned int range_start,
		1869	const char **p_ptr,
		1870	const char *pend,
		1871	char *translate,
		1872	reg_syntax_t syntax,
		1873	unsigned char *b);
		1874	# endif /* WCHAR */
		1875
		1876	/* Fetch the next character in the uncompiled pattern---translating it
		1877	if necessary. Also cast from a signed character in the constant
		1878	string passed to us by the user to an unsigned char that we can use
		1879	as an array index (in, e.g., `translate'). */
		1880	/* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
		1881	because it is impossible to allocate 4GB array for some encodings
		1882	which have 4 byte character_set like UCS4. */
		1883	# ifndef PATFETCH
		1884	# ifdef WCHAR
		1885	# define PATFETCH(c) \
		1886	do {if (p == pend) return REG_EEND; \
		1887	c = (UCHAR_T) *p++; \
		1888	if (translate && (c <= 0xff)) c = (UCHAR_T) translate[c]; \
		1889	} while (0)
		1890	# else /* BYTE */
		1891	# define PATFETCH(c) \
		1892	do {if (p == pend) return REG_EEND; \
		1893	c = (unsigned char) *p++; \
		1894	if (translate) c = (unsigned char) translate[c]; \
		1895	} while (0)
		1896	# endif /* WCHAR */
		1897	# endif
		1898
		1899	/* Fetch the next character in the uncompiled pattern, with no
		1900	translation. */
		1901	# define PATFETCH_RAW(c) \
		1902	do {if (p == pend) return REG_EEND; \
		1903	c = (UCHAR_T) *p++; \
		1904	} while (0)
		1905
		1906	/* Go backwards one character in the pattern. */
		1907	# define PATUNFETCH p--
		1908
		1909
		1910	/* If `translate' is non-null, return translate[D], else just D. We
		1911	cast the subscript to translate because some data is declared as
		1912	`char *', to avoid warnings when a string constant is passed. But
		1913	when we use a character as a subscript we must make it unsigned. */
		1914	/* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
		1915	because it is impossible to allocate 4GB array for some encodings
		1916	which have 4 byte character_set like UCS4. */
		1917
		1918	# ifndef TRANSLATE
		1919	# ifdef WCHAR
		1920	# define TRANSLATE(d) \
		1921	((translate && ((UCHAR_T) (d)) <= 0xff) \
		1922	? (char) translate[(unsigned char) (d)] : (d))
		1923	# else /* BYTE */
		1924	# define TRANSLATE(d) \
		1925	(translate ? (char) translate[(unsigned char) (d)] : (char) (d))
		1926	# endif /* WCHAR */
		1927	# endif
		1928
		1929
		1930	/* Macros for outputting the compiled pattern into `buffer'. */
		1931
		1932	/* If the buffer isn't allocated when it comes in, use this. */
		1933	# define INIT_BUF_SIZE (32 * sizeof(UCHAR_T))
		1934
		1935	/* Make sure we have at least N more bytes of space in buffer. */
		1936	# ifdef WCHAR
		1937	# define GET_BUFFER_SPACE(n) \
		1938	while (((unsigned long)b - (unsigned long)COMPILED_BUFFER_VAR \
		1939	+ (n)*sizeof(CHAR_T)) > bufp->allocated) \
		1940	EXTEND_BUFFER ()
		1941	# else /* BYTE */
		1942	# define GET_BUFFER_SPACE(n) \
		1943	while ((unsigned long) (b - bufp->buffer + (n)) > bufp->allocated) \
		1944	EXTEND_BUFFER ()
		1945	# endif /* WCHAR */
		1946
		1947	/* Make sure we have one more byte of buffer space and then add C to it. */
		1948	# define BUF_PUSH(c) \
		1949	do { \
		1950	GET_BUFFER_SPACE (1); \
		1951	*b++ = (UCHAR_T) (c); \
		1952	} while (0)
		1953
		1954
		1955	/* Ensure we have two more bytes of buffer space and then append C1 and C2. */
		1956	# define BUF_PUSH_2(c1, c2) \
		1957	do { \
		1958	GET_BUFFER_SPACE (2); \
		1959	*b++ = (UCHAR_T) (c1); \
		1960	*b++ = (UCHAR_T) (c2); \
		1961	} while (0)
		1962
		1963
		1964	/* As with BUF_PUSH_2, except for three bytes. */
		1965	# define BUF_PUSH_3(c1, c2, c3) \
		1966	do { \
		1967	GET_BUFFER_SPACE (3); \
		1968	*b++ = (UCHAR_T) (c1); \
		1969	*b++ = (UCHAR_T) (c2); \
		1970	*b++ = (UCHAR_T) (c3); \
		1971	} while (0)
		1972
		1973	/* Store a jump with opcode OP at LOC to location TO. We store a
		1974	relative address offset by the three bytes the jump itself occupies. */
		1975	# define STORE_JUMP(op, loc, to) \
		1976	PREFIX(store_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)))
		1977
		1978	/* Likewise, for a two-argument jump. */
		1979	# define STORE_JUMP2(op, loc, to, arg) \
		1980	PREFIX(store_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), arg)
		1981
		1982	/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */
		1983	# define INSERT_JUMP(op, loc, to) \
		1984	PREFIX(insert_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), b)
		1985
		1986	/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */
		1987	# define INSERT_JUMP2(op, loc, to, arg) \
		1988	PREFIX(insert_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)),\
		1989	arg, b)
		1990
		1991	/* This is not an arbitrary limit: the arguments which represent offsets
		1992	into the pattern are two bytes long. So if 2^16 bytes turns out to
		1993	be too small, many things would have to change. */
		1994	/* Any other compiler which, like MSC, has allocation limit below 2^16
		1995	bytes will have to use approach similar to what was done below for
		1996	MSC and drop MAX_BUF_SIZE a bit. Otherwise you may end up
		1997	reallocating to 0 bytes. Such thing is not going to work too well.
		1998	You have been warned!! */
		1999	# ifndef DEFINED_ONCE
		2000	# if defined _MSC_VER && !defined WIN32
		2001	/* Microsoft C 16-bit versions limit malloc to approx 65512 bytes.
		2002	The REALLOC define eliminates a flurry of conversion warnings,
		2003	but is not required. */
		2004	# define MAX_BUF_SIZE 65500L
		2005	# define REALLOC(p,s) realloc ((p), (size_t) (s))
		2006	# else
		2007	# define MAX_BUF_SIZE (1L << 16)
		2008	# define REALLOC(p,s) realloc ((p), (s))
		2009	# endif
		2010
		2011	/* Extend the buffer by twice its current size via realloc and
		2012	reset the pointers that pointed into the old block to point to the
		2013	correct places in the new one. If extending the buffer results in it
		2014	being larger than MAX_BUF_SIZE, then flag memory exhausted. */
		2015	# if __BOUNDED_POINTERS__
		2016	# define SET_HIGH_BOUND(P) (__ptrhigh (P) = __ptrlow (P) + bufp->allocated)
		2017	# define MOVE_BUFFER_POINTER(P) \
		2018	(__ptrlow (P) += incr, SET_HIGH_BOUND (P), __ptrvalue (P) += incr)
		2019	# define ELSE_EXTEND_BUFFER_HIGH_BOUND \
		2020	else \
		2021	{ \
		2022	SET_HIGH_BOUND (b); \
		2023	SET_HIGH_BOUND (begalt); \
		2024	if (fixup_alt_jump) \
		2025	SET_HIGH_BOUND (fixup_alt_jump); \
		2026	if (laststart) \
		2027	SET_HIGH_BOUND (laststart); \
		2028	if (pending_exact) \
		2029	SET_HIGH_BOUND (pending_exact); \
		2030	}
		2031	# else
		2032	# define MOVE_BUFFER_POINTER(P) (P) += incr
		2033	# define ELSE_EXTEND_BUFFER_HIGH_BOUND
		2034	# endif
		2035	# endif /* not DEFINED_ONCE */
		2036
		2037	# ifdef WCHAR
		2038	# define EXTEND_BUFFER() \
		2039	do { \
		2040	UCHAR_T *old_buffer = COMPILED_BUFFER_VAR; \
		2041	int wchar_count; \
		2042	if (bufp->allocated + sizeof(UCHAR_T) > MAX_BUF_SIZE) \
		2043	return REG_ESIZE; \
		2044	bufp->allocated <<= 1; \
		2045	if (bufp->allocated > MAX_BUF_SIZE) \
		2046	bufp->allocated = MAX_BUF_SIZE; \
		2047	/* How many characters the new buffer can have? */ \
		2048	wchar_count = bufp->allocated / sizeof(UCHAR_T); \
		2049	if (wchar_count == 0) wchar_count = 1; \
		2050	/* Truncate the buffer to CHAR_T align. */ \
		2051	bufp->allocated = wchar_count * sizeof(UCHAR_T); \
		2052	RETALLOC (COMPILED_BUFFER_VAR, wchar_count, UCHAR_T); \
		2053	bufp->buffer = (char*)COMPILED_BUFFER_VAR; \
		2054	if (COMPILED_BUFFER_VAR == NULL) \
		2055	return REG_ESPACE; \
		2056	/* If the buffer moved, move all the pointers into it. */ \
		2057	if (old_buffer != COMPILED_BUFFER_VAR) \
		2058	{ \
		2059	PTR_INT_TYPE incr = COMPILED_BUFFER_VAR - old_buffer; \
		2060	MOVE_BUFFER_POINTER (b); \
		2061	MOVE_BUFFER_POINTER (begalt); \
		2062	if (fixup_alt_jump) \
		2063	MOVE_BUFFER_POINTER (fixup_alt_jump); \
		2064	if (laststart) \
		2065	MOVE_BUFFER_POINTER (laststart); \
		2066	if (pending_exact) \
		2067	MOVE_BUFFER_POINTER (pending_exact); \
		2068	} \
		2069	ELSE_EXTEND_BUFFER_HIGH_BOUND \
		2070	} while (0)
		2071	# else /* BYTE */
		2072	# define EXTEND_BUFFER() \
		2073	do { \
		2074	UCHAR_T *old_buffer = COMPILED_BUFFER_VAR; \
		2075	if (bufp->allocated == MAX_BUF_SIZE) \
		2076	return REG_ESIZE; \
		2077	bufp->allocated <<= 1; \
		2078	if (bufp->allocated > MAX_BUF_SIZE) \
		2079	bufp->allocated = MAX_BUF_SIZE; \
		2080	bufp->buffer = (UCHAR_T *) REALLOC (COMPILED_BUFFER_VAR, \
		2081	bufp->allocated); \
		2082	if (COMPILED_BUFFER_VAR == NULL) \
		2083	return REG_ESPACE; \
		2084	/* If the buffer moved, move all the pointers into it. */ \
		2085	if (old_buffer != COMPILED_BUFFER_VAR) \
		2086	{ \
		2087	PTR_INT_TYPE incr = COMPILED_BUFFER_VAR - old_buffer; \
		2088	MOVE_BUFFER_POINTER (b); \
		2089	MOVE_BUFFER_POINTER (begalt); \
		2090	if (fixup_alt_jump) \
		2091	MOVE_BUFFER_POINTER (fixup_alt_jump); \
		2092	if (laststart) \
		2093	MOVE_BUFFER_POINTER (laststart); \
		2094	if (pending_exact) \
		2095	MOVE_BUFFER_POINTER (pending_exact); \
		2096	} \
		2097	ELSE_EXTEND_BUFFER_HIGH_BOUND \
		2098	} while (0)
		2099	# endif /* WCHAR */
		2100
		2101	# ifndef DEFINED_ONCE
		2102	/* Since we have one byte reserved for the register number argument to
		2103	{start,stop}_memory, the maximum number of groups we can report
		2104	things about is what fits in that byte. */
		2105	# define MAX_REGNUM 255
		2106
		2107	/* But patterns can have more than `MAX_REGNUM' registers. We just
		2108	ignore the excess. */
		2109	typedef unsigned regnum_t;
		2110
		2111
		2112	/* Macros for the compile stack. */
		2113
		2114	/* Since offsets can go either forwards or backwards, this type needs to
		2115	be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */
		2116	/* int may be not enough when sizeof(int) == 2. */
		2117	typedef long pattern_offset_t;
		2118
		2119	typedef struct
		2120	{
		2121	pattern_offset_t begalt_offset;
		2122	pattern_offset_t fixup_alt_jump;
		2123	pattern_offset_t inner_group_offset;
		2124	pattern_offset_t laststart_offset;
		2125	regnum_t regnum;
		2126	} compile_stack_elt_t;
		2127
		2128
		2129	typedef struct
		2130	{
		2131	compile_stack_elt_t *stack;
		2132	unsigned size;
		2133	unsigned avail; /* Offset of next open position. */
		2134	} compile_stack_type;
		2135
		2136
		2137	# define INIT_COMPILE_STACK_SIZE 32
		2138
		2139	# define COMPILE_STACK_EMPTY (compile_stack.avail == 0)
		2140	# define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size)
		2141
		2142	/* The next available element. */
		2143	# define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
		2144
		2145	# endif /* not DEFINED_ONCE */
		2146
		2147	/* Set the bit for character C in a list. */
		2148	# ifndef DEFINED_ONCE
		2149	# define SET_LIST_BIT(c) \
		2150	(b[((unsigned char) (c)) / BYTEWIDTH] \
		2151	\|= 1 << (((unsigned char) c) % BYTEWIDTH))
		2152	# endif /* DEFINED_ONCE */
		2153
		2154	/* Get the next unsigned number in the uncompiled pattern. */
		2155	# define GET_UNSIGNED_NUMBER(num) \
		2156	{ \
		2157	while (p != pend) \
		2158	{ \
		2159	PATFETCH (c); \
		2160	if (c < '0' \|\| c > '9') \
		2161	break; \
		2162	if (num <= RE_DUP_MAX) \
		2163	{ \
		2164	if (num < 0) \
		2165	num = 0; \
		2166	num = num * 10 + c - '0'; \
		2167	} \
		2168	} \
		2169	}
		2170
		2171	# ifndef DEFINED_ONCE
		2172	# if defined _LIBC \|\| WIDE_CHAR_SUPPORT
		2173	/* The GNU C library provides support for user-defined character classes
		2174	and the functions from ISO C amendement 1. */
		2175	# ifdef CHARCLASS_NAME_MAX
		2176	# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
		2177	# else
		2178	/* This shouldn't happen but some implementation might still have this
		2179	problem. Use a reasonable default value. */
		2180	# define CHAR_CLASS_MAX_LENGTH 256
		2181	# endif
		2182
		2183	# ifdef _LIBC
		2184	# define IS_CHAR_CLASS(string) __wctype (string)
		2185	# else
		2186	# define IS_CHAR_CLASS(string) wctype (string)
		2187	# endif
		2188	# else
		2189	# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */
		2190
		2191	# define IS_CHAR_CLASS(string) \
		2192	(STREQ (string, "alpha") \|\| STREQ (string, "upper") \
		2193	\|\| STREQ (string, "lower") \|\| STREQ (string, "digit") \
		2194	\|\| STREQ (string, "alnum") \|\| STREQ (string, "xdigit") \
		2195	\|\| STREQ (string, "space") \|\| STREQ (string, "print") \
		2196	\|\| STREQ (string, "punct") \|\| STREQ (string, "graph") \
		2197	\|\| STREQ (string, "cntrl") \|\| STREQ (string, "blank"))
		2198	# endif
		2199	# endif /* DEFINED_ONCE */
		2200
		2201	# ifndef MATCH_MAY_ALLOCATE
		2202
		2203	/* If we cannot allocate large objects within re_match_2_internal,
		2204	we make the fail stack and register vectors global.
		2205	The fail stack, we grow to the maximum size when a regexp
		2206	is compiled.
		2207	The register vectors, we adjust in size each time we
		2208	compile a regexp, according to the number of registers it needs. */
		2209
		2210	static PREFIX(fail_stack_type) fail_stack;
		2211
		2212	/* Size with which the following vectors are currently allocated.
		2213	That is so we can make them bigger as needed,
		2214	but never make them smaller. */
		2215	# ifdef DEFINED_ONCE
		2216	static int regs_allocated_size;
		2217
		2218	static const char regstart, regend;
		2219	static const char old_regstart, old_regend;
		2220	static const char best_regstart, best_regend;
		2221	static const char **reg_dummy;
		2222	# endif /* DEFINED_ONCE */
		2223
		2224	static PREFIX(register_info_type) *PREFIX(reg_info);
		2225	static PREFIX(register_info_type) *PREFIX(reg_info_dummy);
		2226
		2227	/* Make the register vectors big enough for NUM_REGS registers,
		2228	but don't make them smaller. */
		2229
		2230	static void
		2231	PREFIX(regex_grow_registers) (int num_regs)
		2232	{
		2233	if (num_regs > regs_allocated_size)
		2234	{
		2235	RETALLOC_IF (regstart, num_regs, const char *);
		2236	RETALLOC_IF (regend, num_regs, const char *);
		2237	RETALLOC_IF (old_regstart, num_regs, const char *);
		2238	RETALLOC_IF (old_regend, num_regs, const char *);
		2239	RETALLOC_IF (best_regstart, num_regs, const char *);
		2240	RETALLOC_IF (best_regend, num_regs, const char *);
		2241	RETALLOC_IF (PREFIX(reg_info), num_regs, PREFIX(register_info_type));
		2242	RETALLOC_IF (reg_dummy, num_regs, const char *);
		2243	RETALLOC_IF (PREFIX(reg_info_dummy), num_regs, PREFIX(register_info_type));
		2244
		2245	regs_allocated_size = num_regs;
		2246	}
		2247	}
		2248
		2249	# endif /* not MATCH_MAY_ALLOCATE */
		2250
		2251	# ifndef DEFINED_ONCE
		2252	static boolean group_in_compile_stack (compile_stack_type compile_stack,
		2253	regnum_t regnum);
		2254	# endif /* not DEFINED_ONCE */
		2255
		2256	/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
		2257	Returns one of error codes defined in `regex.h', or zero for success.
		2258
		2259	Assumes the `allocated' (and perhaps `buffer') and `translate'
		2260	fields are set in BUFP on entry.
		2261
		2262	If it succeeds, results are put in BUFP (if it returns an error, the
		2263	contents of BUFP are undefined):
		2264	`buffer' is the compiled pattern;
		2265	`syntax' is set to SYNTAX;
		2266	`used' is set to the length of the compiled pattern;
		2267	`fastmap_accurate' is zero;
		2268	`re_nsub' is the number of subexpressions in PATTERN;
		2269	`not_bol' and `not_eol' are zero;
		2270
		2271	The `fastmap' and `newline_anchor' fields are neither
		2272	examined nor set. */
		2273
		2274	/* Return, freeing storage we allocated. */
		2275	# ifdef WCHAR
		2276	# define FREE_STACK_RETURN(value) \
		2277	return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
		2278	# else
		2279	# define FREE_STACK_RETURN(value) \
		2280	return (free (compile_stack.stack), value)
		2281	# endif /* WCHAR */
		2282
		2283	static reg_errcode_t
		2284	PREFIX(regex_compile) (const char *ARG_PREFIX(pattern),
		2285	size_t ARG_PREFIX(size), reg_syntax_t syntax,
		2286	struct re_pattern_buffer *bufp)
		2287	{
		2288	/* We fetch characters from PATTERN here. Even though PATTERN is
		2289	`char *' (i.e., signed), we declare these variables as unsigned, so
		2290	they can be reliably used as array indices. */
		2291	register UCHAR_T c, c1;
		2292
		2293	#ifdef WCHAR
		2294	/* A temporary space to keep wchar_t pattern and compiled pattern. */
		2295	CHAR_T pattern, COMPILED_BUFFER_VAR;
		2296	size_t size;
		2297	/* offset buffer for optimization. See convert_mbs_to_wc. */
		2298	int *mbs_offset = NULL;
		2299	/* It hold whether each wchar_t is binary data or not. */
		2300	char *is_binary = NULL;
		2301	/* A flag whether exactn is handling binary data or not. */
		2302	char is_exactn_bin = FALSE;
		2303	#endif /* WCHAR */
		2304
		2305	/* A random temporary spot in PATTERN. */
		2306	const CHAR_T *p1;
		2307
		2308	/* Points to the end of the buffer, where we should append. */
		2309	register UCHAR_T *b;
		2310
		2311	/* Keeps track of unclosed groups. */
		2312	compile_stack_type compile_stack;
		2313
		2314	/* Points to the current (ending) position in the pattern. */
		2315	#ifdef WCHAR
		2316	const CHAR_T *p;
		2317	const CHAR_T *pend;
		2318	#else /* BYTE */
		2319	const CHAR_T *p = pattern;
		2320	const CHAR_T *pend = pattern + size;
		2321	#endif /* WCHAR */
		2322
		2323	/* How to translate the characters in the pattern. */
		2324	RE_TRANSLATE_TYPE translate = bufp->translate;
		2325
		2326	/* Address of the count-byte of the most recently inserted `exactn'
		2327	command. This makes it possible to tell if a new exact-match
		2328	character can be added to that command or if the character requires
		2329	a new `exactn' command. */
		2330	UCHAR_T *pending_exact = 0;
		2331
		2332	/* Address of start of the most recently finished expression.
		2333	This tells, e.g., postfix * where to find the start of its
		2334	operand. Reset at the beginning of groups and alternatives. */
		2335	UCHAR_T *laststart = 0;
		2336
		2337	/* Address of beginning of regexp, or inside of last group. */
		2338	UCHAR_T *begalt;
		2339
		2340	/* Address of the place where a forward jump should go to the end of
		2341	the containing expression. Each alternative of an `or' -- except the
		2342	last -- ends with a forward jump of this sort. */
		2343	UCHAR_T *fixup_alt_jump = 0;
		2344
		2345	/* Counts open-groups as they are encountered. Remembered for the
		2346	matching close-group on the compile stack, so the same register
		2347	number is put in the stop_memory as the start_memory. */
		2348	regnum_t regnum = 0;
		2349
		2350	#ifdef WCHAR
		2351	/* Initialize the wchar_t PATTERN and offset_buffer. */
		2352	p = pend = pattern = TALLOC(csize + 1, CHAR_T);
		2353	mbs_offset = TALLOC(csize + 1, int);
		2354	is_binary = TALLOC(csize + 1, char);
		2355	if (pattern == NULL \|\| mbs_offset == NULL \|\| is_binary == NULL)
		2356	{
		2357	free(pattern);
		2358	free(mbs_offset);
		2359	free(is_binary);
		2360	return REG_ESPACE;
		2361	}
		2362	pattern[csize] = L'\0'; /* sentinel */
		2363	size = convert_mbs_to_wcs(pattern, cpattern, csize, mbs_offset, is_binary);
		2364	pend = p + size;
		2365	if (size < 0)
		2366	{
		2367	free(pattern);
		2368	free(mbs_offset);
		2369	free(is_binary);
		2370	return REG_BADPAT;
		2371	}
		2372	#endif
		2373
		2374	#ifdef DEBUG
		2375	DEBUG_PRINT1 ("\nCompiling pattern: ");
		2376	if (debug)
		2377	{
		2378	unsigned debug_count;
		2379
		2380	for (debug_count = 0; debug_count < size; debug_count++)
		2381	PUT_CHAR (pattern[debug_count]);
		2382	putchar ('\n');
		2383	}
		2384	#endif /* DEBUG */
		2385
		2386	/* Initialize the compile stack. */
		2387	compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
		2388	if (compile_stack.stack == NULL)
		2389	{
		2390	#ifdef WCHAR
		2391	free(pattern);
		2392	free(mbs_offset);
		2393	free(is_binary);
		2394	#endif
		2395	return REG_ESPACE;
		2396	}
		2397
		2398	compile_stack.size = INIT_COMPILE_STACK_SIZE;
		2399	compile_stack.avail = 0;
		2400
		2401	/* Initialize the pattern buffer. */
		2402	bufp->syntax = syntax;
		2403	bufp->fastmap_accurate = 0;
		2404	bufp->not_bol = bufp->not_eol = 0;
		2405
		2406	/* Set `used' to zero, so that if we return an error, the pattern
		2407	printer (for debugging) will think there's no pattern. We reset it
		2408	at the end. */
		2409	bufp->used = 0;
		2410
		2411	/* Always count groups, whether or not bufp->no_sub is set. */
		2412	bufp->re_nsub = 0;
		2413
		2414	#if !defined emacs && !defined SYNTAX_TABLE
		2415	/* Initialize the syntax table. */
		2416	init_syntax_once ();
		2417	#endif
		2418
		2419	if (bufp->allocated == 0)
		2420	{
		2421	if (bufp->buffer)
		2422	{ /* If zero allocated, but buffer is non-null, try to realloc
		2423	enough space. This loses if buffer's address is bogus, but
		2424	that is the user's responsibility. */
		2425	#ifdef WCHAR
		2426	/* Free bufp->buffer and allocate an array for wchar_t pattern
		2427	buffer. */
		2428	free(bufp->buffer);
		2429	COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE/sizeof(UCHAR_T),
		2430	UCHAR_T);
		2431	#else
		2432	RETALLOC (COMPILED_BUFFER_VAR, INIT_BUF_SIZE, UCHAR_T);
		2433	#endif /* WCHAR */
		2434	}
		2435	else
		2436	{ /* Caller did not allocate a buffer. Do it for them. */
		2437	COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE / sizeof(UCHAR_T),
		2438	UCHAR_T);
		2439	}
		2440
		2441	if (!COMPILED_BUFFER_VAR) FREE_STACK_RETURN (REG_ESPACE);
		2442	#ifdef WCHAR
		2443	bufp->buffer = (char*)COMPILED_BUFFER_VAR;
		2444	#endif /* WCHAR */
		2445	bufp->allocated = INIT_BUF_SIZE;
		2446	}
		2447	#ifdef WCHAR
		2448	else
		2449	COMPILED_BUFFER_VAR = (UCHAR_T*) bufp->buffer;
		2450	#endif
		2451
		2452	begalt = b = COMPILED_BUFFER_VAR;
		2453
		2454	/* Loop through the uncompiled pattern until we're at the end. */
		2455	while (p != pend)
		2456	{
		2457	PATFETCH (c);
		2458
		2459	switch (c)
		2460	{
		2461	case '^':
		2462	{
		2463	if ( /* If at start of pattern, it's an operator. */
		2464	p == pattern + 1
		2465	/* If context independent, it's an operator. */
		2466	\|\| syntax & RE_CONTEXT_INDEP_ANCHORS
		2467	/* Otherwise, depends on what's come before. */
		2468	\|\| PREFIX(at_begline_loc_p) (pattern, p, syntax))
		2469	BUF_PUSH (begline);
		2470	else
		2471	goto normal_char;
		2472	}
		2473	break;
		2474
		2475
		2476	case '$':
		2477	{
		2478	if ( /* If at end of pattern, it's an operator. */
		2479	p == pend
		2480	/* If context independent, it's an operator. */
		2481	\|\| syntax & RE_CONTEXT_INDEP_ANCHORS
		2482	/* Otherwise, depends on what's next. */
		2483	\|\| PREFIX(at_endline_loc_p) (p, pend, syntax))
		2484	BUF_PUSH (endline);
		2485	else
		2486	goto normal_char;
		2487	}
		2488	break;
		2489
		2490
		2491	case '+':
		2492	case '?':
		2493	if ((syntax & RE_BK_PLUS_QM)
		2494	\|\| (syntax & RE_LIMITED_OPS))
		2495	goto normal_char;
		2496	handle_plus:
		2497	case '*':
		2498	/* If there is no previous pattern... */
		2499	if (!laststart)
		2500	{
		2501	if (syntax & RE_CONTEXT_INVALID_OPS)
		2502	FREE_STACK_RETURN (REG_BADRPT);
		2503	else if (!(syntax & RE_CONTEXT_INDEP_OPS))
		2504	goto normal_char;
		2505	}
		2506
		2507	{
		2508	/* Are we optimizing this jump? */
		2509	boolean keep_string_p = false;
		2510
		2511	/* 1 means zero (many) matches is allowed. */
		2512	char zero_times_ok = 0, many_times_ok = 0;
		2513
		2514	/* If there is a sequence of repetition chars, collapse it
		2515	down to just one (the right one). We can't combine
		2516	interval operators with these because of, e.g., `a{2}*',
		2517	which should only match an even number of `a's. */
		2518
		2519	for (;;)
		2520	{
		2521	zero_times_ok \|= c != '+';
		2522	many_times_ok \|= c != '?';
		2523
		2524	if (p == pend)
		2525	break;
		2526
		2527	PATFETCH (c);
		2528
		2529	if (c == '*'
		2530	\|\| (!(syntax & RE_BK_PLUS_QM) && (c == '+' \|\| c == '?')))
		2531	;
		2532
		2533	else if (syntax & RE_BK_PLUS_QM && c == '\\')
		2534	{
		2535	if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
		2536
		2537	PATFETCH (c1);
		2538	if (!(c1 == '+' \|\| c1 == '?'))
		2539	{
		2540	PATUNFETCH;
		2541	PATUNFETCH;
		2542	break;
		2543	}
		2544
		2545	c = c1;
		2546	}
		2547	else
		2548	{
		2549	PATUNFETCH;
		2550	break;
		2551	}
		2552
		2553	/* If we get here, we found another repeat character. */
		2554	}
		2555
		2556	/* Star, etc. applied to an empty pattern is equivalent
		2557	to an empty pattern. */
		2558	if (!laststart)
		2559	break;
		2560
		2561	/* Now we know whether or not zero matches is allowed
		2562	and also whether or not two or more matches is allowed. */
		2563	if (many_times_ok)
		2564	{ /* More than one repetition is allowed, so put in at the
		2565	end a backward relative jump from `b' to before the next
		2566	jump we're going to put in below (which jumps from
		2567	laststart to after this jump).
		2568
		2569	But if we are at the `' in the exact sequence `.\n',
		2570	insert an unconditional jump backwards to the .,
		2571	instead of the beginning of the loop. This way we only
		2572	push a failure point once, instead of every time
		2573	through the loop. */
		2574	assert (p - 1 > pattern);
		2575
		2576	/* Allocate the space for the jump. */
		2577	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		2578
		2579	/* We know we are not at the first character of the pattern,
		2580	because laststart was nonzero. And we've already
		2581	incremented `p', by the way, to be the character after
		2582	the `*'. Do we have to do something analogous here
		2583	for null bytes, because of RE_DOT_NOT_NULL? */
		2584	if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')
		2585	&& zero_times_ok
		2586	&& p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
		2587	&& !(syntax & RE_DOT_NEWLINE))
		2588	{ /* We have .\n. /
		2589	STORE_JUMP (jump, b, laststart);
		2590	keep_string_p = true;
		2591	}
		2592	else
		2593	/* Anything else. */
		2594	STORE_JUMP (maybe_pop_jump, b, laststart -
		2595	(1 + OFFSET_ADDRESS_SIZE));
		2596
		2597	/* We've added more stuff to the buffer. */
		2598	b += 1 + OFFSET_ADDRESS_SIZE;
		2599	}
		2600
		2601	/* On failure, jump from laststart to b + 3, which will be the
		2602	end of the buffer after this jump is inserted. */
		2603	/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' instead of
		2604	'b + 3'. */
		2605	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		2606	INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
		2607	: on_failure_jump,
		2608	laststart, b + 1 + OFFSET_ADDRESS_SIZE);
		2609	pending_exact = 0;
		2610	b += 1 + OFFSET_ADDRESS_SIZE;
		2611
		2612	if (!zero_times_ok)
		2613	{
		2614	/* At least one repetition is required, so insert a
		2615	`dummy_failure_jump' before the initial
		2616	`on_failure_jump' instruction of the loop. This
		2617	effects a skip over that instruction the first time
		2618	we hit that loop. */
		2619	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		2620	INSERT_JUMP (dummy_failure_jump, laststart, laststart +
		2621	2 + 2 * OFFSET_ADDRESS_SIZE);
		2622	b += 1 + OFFSET_ADDRESS_SIZE;
		2623	}
		2624	}
		2625	break;
		2626
		2627
		2628	case '.':
		2629	laststart = b;
		2630	BUF_PUSH (anychar);
		2631	break;
		2632
		2633
		2634	case '[':
		2635	{
		2636	boolean had_char_class = false;
		2637	#ifdef WCHAR
		2638	CHAR_T range_start = 0xffffffff;
		2639	#else
		2640	unsigned int range_start = 0xffffffff;
		2641	#endif
		2642	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		2643
		2644	#ifdef WCHAR
		2645	/* We assume a charset(_not) structure as a wchar_t array.
		2646	charset[0] = (re_opcode_t) charset(_not)
		2647	charset[1] = l (= length of char_classes)
		2648	charset[2] = m (= length of collating_symbols)
		2649	charset[3] = n (= length of equivalence_classes)
		2650	charset[4] = o (= length of char_ranges)
		2651	charset[5] = p (= length of chars)
		2652
		2653	charset[6] = char_class (wctype_t)
		2654	charset[6+CHAR_CLASS_SIZE] = char_class (wctype_t)
		2655	...
		2656	charset[l+5] = char_class (wctype_t)
		2657
		2658	charset[l+6] = collating_symbol (wchar_t)
		2659	...
		2660	charset[l+m+5] = collating_symbol (wchar_t)
		2661	ifdef _LIBC we use the index if
		2662	_NL_COLLATE_SYMB_EXTRAMB instead of
		2663	wchar_t string.
		2664
		2665	charset[l+m+6] = equivalence_classes (wchar_t)
		2666	...
		2667	charset[l+m+n+5] = equivalence_classes (wchar_t)
		2668	ifdef _LIBC we use the index in
		2669	_NL_COLLATE_WEIGHT instead of
		2670	wchar_t string.
		2671
		2672	charset[l+m+n+6] = range_start
		2673	charset[l+m+n+7] = range_end
		2674	...
		2675	charset[l+m+n+2o+4] = range_start
		2676	charset[l+m+n+2o+5] = range_end
		2677	ifdef _LIBC we use the value looked up
		2678	in _NL_COLLATE_COLLSEQ instead of
		2679	wchar_t character.
		2680
		2681	charset[l+m+n+2o+6] = char
		2682	...
		2683	charset[l+m+n+2o+p+5] = char
		2684
		2685	*/
		2686
		2687	/* We need at least 6 spaces: the opcode, the length of
		2688	char_classes, the length of collating_symbols, the length of
		2689	equivalence_classes, the length of char_ranges, the length of
		2690	chars. */
		2691	GET_BUFFER_SPACE (6);
		2692
		2693	/* Save b as laststart. And We use laststart as the pointer
		2694	to the first element of the charset here.
		2695	In other words, laststart[i] indicates charset[i]. */
		2696	laststart = b;
		2697
		2698	/* We test `*p == '^' twice, instead of using an if
		2699	statement, so we only need one BUF_PUSH. */
		2700	BUF_PUSH (*p == '^' ? charset_not : charset);
		2701	if (*p == '^')
		2702	p++;
		2703
		2704	/* Push the length of char_classes, the length of
		2705	collating_symbols, the length of equivalence_classes, the
		2706	length of char_ranges and the length of chars. */
		2707	BUF_PUSH_3 (0, 0, 0);
		2708	BUF_PUSH_2 (0, 0);
		2709
		2710	/* Remember the first position in the bracket expression. */
		2711	p1 = p;
		2712
		2713	/* charset_not matches newline according to a syntax bit. */
		2714	if ((re_opcode_t) b[-6] == charset_not
		2715	&& (syntax & RE_HAT_LISTS_NOT_NEWLINE))
		2716	{
		2717	BUF_PUSH('\n');
		2718	laststart[5]++; /* Update the length of characters */
		2719	}
		2720
		2721	/* Read in characters and ranges, setting map bits. */
		2722	for (;;)
		2723	{
		2724	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		2725
		2726	PATFETCH (c);
		2727
		2728	/* \ might escape characters inside [...] and [^...]. */
		2729	if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
		2730	{
		2731	if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
		2732
		2733	PATFETCH (c1);
		2734	BUF_PUSH(c1);
		2735	laststart[5]++; /* Update the length of chars */
		2736	range_start = c1;
		2737	continue;
		2738	}
		2739
		2740	/* Could be the end of the bracket expression. If it's
		2741	not (i.e., when the bracket expression is `[]' so
		2742	far), the ']' character bit gets set way below. */
		2743	if (c == ']' && p != p1 + 1)
		2744	break;
		2745
		2746	/* Look ahead to see if it's a range when the last thing
		2747	was a character class. */
		2748	if (had_char_class && c == '-' && *p != ']')
		2749	FREE_STACK_RETURN (REG_ERANGE);
		2750
		2751	/* Look ahead to see if it's a range when the last thing
		2752	was a character: if this is a hyphen not at the
		2753	beginning or the end of a list, then it's the range
		2754	operator. */
		2755	if (c == '-'
		2756	&& !(p - 2 >= pattern && p[-2] == '[')
		2757	&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
		2758	&& *p != ']')
		2759	{
		2760	reg_errcode_t ret;
		2761	/* Allocate the space for range_start and range_end. */
		2762	GET_BUFFER_SPACE (2);
		2763	/* Update the pointer to indicate end of buffer. */
		2764	b += 2;
		2765	ret = wcs_compile_range (range_start, &p, pend, translate,
		2766	syntax, b, laststart);
		2767	if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
		2768	range_start = 0xffffffff;
		2769	}
		2770	else if (p[0] == '-' && p[1] != ']')
		2771	{ /* This handles ranges made up of characters only. */
		2772	reg_errcode_t ret;
		2773
		2774	/* Move past the `-'. */
		2775	PATFETCH (c1);
		2776	/* Allocate the space for range_start and range_end. */
		2777	GET_BUFFER_SPACE (2);
		2778	/* Update the pointer to indicate end of buffer. */
		2779	b += 2;
		2780	ret = wcs_compile_range (c, &p, pend, translate, syntax, b,
		2781	laststart);
		2782	if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
		2783	range_start = 0xffffffff;
		2784	}
		2785
		2786	/* See if we're at the beginning of a possible character
		2787	class. */
		2788	else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
		2789	{ /* Leave room for the null. */
		2790	char str[CHAR_CLASS_MAX_LENGTH + 1];
		2791
		2792	PATFETCH (c);
		2793	c1 = 0;
		2794
		2795	/* If pattern is `[[:'. */
		2796	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		2797
		2798	for (;;)
		2799	{
		2800	PATFETCH (c);
		2801	if ((c == ':' && *p == ']') \|\| p == pend)
		2802	break;
		2803	if (c1 < CHAR_CLASS_MAX_LENGTH)
		2804	str[c1++] = c;
		2805	else
		2806	/* This is in any case an invalid class name. */
		2807	str[0] = '\0';
		2808	}
		2809	str[c1] = '\0';
		2810
		2811	/* If isn't a word bracketed by `[:' and `:]':
		2812	undo the ending character, the letters, and leave
		2813	the leading `:' and `[' (but store them as character). */
		2814	if (c == ':' && *p == ']')
		2815	{
		2816	wctype_t wt;
		2817	uintptr_t alignedp;
		2818
		2819	/* Query the character class as wctype_t. */
		2820	wt = IS_CHAR_CLASS (str);
		2821	if (wt == 0)
		2822	FREE_STACK_RETURN (REG_ECTYPE);
		2823
		2824	/* Throw away the ] at the end of the character
		2825	class. */
		2826	PATFETCH (c);
		2827
		2828	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		2829
		2830	/* Allocate the space for character class. */
		2831	GET_BUFFER_SPACE(CHAR_CLASS_SIZE);
		2832	/* Update the pointer to indicate end of buffer. */
		2833	b += CHAR_CLASS_SIZE;
		2834	/* Move data which follow character classes
		2835	not to violate the data. */
		2836	insert_space(CHAR_CLASS_SIZE,
		2837	laststart + 6 + laststart[1],
		2838	b - 1);
		2839	alignedp = ((uintptr_t)(laststart + 6 + laststart[1])
		2840	+ __alignof__(wctype_t) - 1)
		2841	& ~(uintptr_t)(__alignof__(wctype_t) - 1);
		2842	/* Store the character class. */
		2843	((wctype_t)alignedp) = wt;
		2844	/* Update length of char_classes */
		2845	laststart[1] += CHAR_CLASS_SIZE;
		2846
		2847	had_char_class = true;
		2848	}
		2849	else
		2850	{
		2851	c1++;
		2852	while (c1--)
		2853	PATUNFETCH;
		2854	BUF_PUSH ('[');
		2855	BUF_PUSH (':');
		2856	laststart[5] += 2; /* Update the length of characters */
		2857	range_start = ':';
		2858	had_char_class = false;
		2859	}
		2860	}
		2861	else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '='
		2862	\|\| *p == '.'))
		2863	{
		2864	CHAR_T str[128]; /* Should be large enough. */
		2865	CHAR_T delim = p; / '=' or '.' */
		2866	# ifdef _LIBC
		2867	uint32_t nrules =
		2868	_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
		2869	# endif
		2870	PATFETCH (c);
		2871	c1 = 0;
		2872
		2873	/* If pattern is `[[=' or '[[.'. */
		2874	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		2875
		2876	for (;;)
		2877	{
		2878	PATFETCH (c);
		2879	if ((c == delim && *p == ']') \|\| p == pend)
		2880	break;
		2881	if (c1 < sizeof (str) - 1)
		2882	str[c1++] = c;
		2883	else
		2884	/* This is in any case an invalid class name. */
		2885	str[0] = '\0';
		2886	}
		2887	str[c1] = '\0';
		2888
		2889	if (c == delim && *p == ']' && str[0] != '\0')
		2890	{
		2891	unsigned int i, offset;
		2892	/* If we have no collation data we use the default
		2893	collation in which each character is in a class
		2894	by itself. It also means that ASCII is the
		2895	character set and therefore we cannot have character
		2896	with more than one byte in the multibyte
		2897	representation. */
		2898
		2899	/* If not defined _LIBC, we push the name and
		2900	`\0' for the sake of matching performance. */
		2901	int datasize = c1 + 1;
		2902
		2903	# ifdef _LIBC
		2904	int32_t idx = 0;
		2905	if (nrules == 0)
		2906	# endif
		2907	{
		2908	if (c1 != 1)
		2909	FREE_STACK_RETURN (REG_ECOLLATE);
		2910	}
		2911	# ifdef _LIBC
		2912	else
		2913	{
		2914	const int32_t *table;
		2915	const int32_t *weights;
		2916	const int32_t *extra;
		2917	const int32_t *indirect;
		2918	wint_t *cp;
		2919
		2920	/* This #include defines a local function! */
		2921	# include
		2922
		2923	if(delim == '=')
		2924	{
		2925	/* We push the index for equivalence class. */
		2926	cp = (wint_t*)str;
		2927
		2928	table = (const int32_t *)
		2929	_NL_CURRENT (LC_COLLATE,
		2930	_NL_COLLATE_TABLEWC);
		2931	weights = (const int32_t *)
		2932	_NL_CURRENT (LC_COLLATE,
		2933	_NL_COLLATE_WEIGHTWC);
		2934	extra = (const int32_t *)
		2935	_NL_CURRENT (LC_COLLATE,
		2936	_NL_COLLATE_EXTRAWC);
		2937	indirect = (const int32_t *)
		2938	_NL_CURRENT (LC_COLLATE,
		2939	_NL_COLLATE_INDIRECTWC);
		2940
		2941	idx = findidx ((const wint_t**)&cp);
		2942	if (idx == 0 \|\| cp < (wint_t*) str + c1)
		2943	/* This is no valid character. */
		2944	FREE_STACK_RETURN (REG_ECOLLATE);
		2945
		2946	str[0] = (wchar_t)idx;
		2947	}
		2948	else /* delim == '.' */
		2949	{
		2950	/* We push collation sequence value
		2951	for collating symbol. */
		2952	int32_t table_size;
		2953	const int32_t *symb_table;
		2954	const unsigned char *extra;
		2955	int32_t idx;
		2956	int32_t elem;
		2957	int32_t second;
		2958	int32_t hash;
		2959	char char_str[c1];
		2960
		2961	/* We have to convert the name to a single-byte
		2962	string. This is possible since the names
		2963	consist of ASCII characters and the internal
		2964	representation is UCS4. */
		2965	for (i = 0; i < c1; ++i)
		2966	char_str[i] = str[i];
		2967
		2968	table_size =
		2969	_NL_CURRENT_WORD (LC_COLLATE,
		2970	_NL_COLLATE_SYMB_HASH_SIZEMB);
		2971	symb_table = (const int32_t *)
		2972	_NL_CURRENT (LC_COLLATE,
		2973	_NL_COLLATE_SYMB_TABLEMB);
		2974	extra = (const unsigned char *)
		2975	_NL_CURRENT (LC_COLLATE,
		2976	_NL_COLLATE_SYMB_EXTRAMB);
		2977
		2978	/* Locate the character in the hashing table. */
		2979	hash = elem_hash (char_str, c1);
		2980
		2981	idx = 0;
		2982	elem = hash % table_size;
		2983	second = hash % (table_size - 2);
		2984	while (symb_table[2 * elem] != 0)
		2985	{
		2986	/* First compare the hashing value. */
		2987	if (symb_table[2 * elem] == hash
		2988	&& c1 == extra[symb_table[2 * elem + 1]]
		2989	&& memcmp (char_str,
		2990	&extra[symb_table[2 * elem + 1]
		2991	+ 1], c1) == 0)
		2992	{
		2993	/* Yep, this is the entry. */
		2994	idx = symb_table[2 * elem + 1];
		2995	idx += 1 + extra[idx];
		2996	break;
		2997	}
		2998
		2999	/* Next entry. */
		3000	elem += second;
		3001	}
		3002
		3003	if (symb_table[2 * elem] != 0)
		3004	{
		3005	/* Compute the index of the byte sequence
		3006	in the table. */
		3007	idx += 1 + extra[idx];
		3008	/* Adjust for the alignment. */
		3009	idx = (idx + 3) & ~3;
		3010
		3011	str[0] = (wchar_t) idx + 4;
		3012	}
		3013	else if (symb_table[2 * elem] == 0 && c1 == 1)
		3014	{
		3015	/* No valid character. Match it as a
		3016	single byte character. */
		3017	had_char_class = false;
		3018	BUF_PUSH(str[0]);
		3019	/* Update the length of characters */
		3020	laststart[5]++;
		3021	range_start = str[0];
		3022
		3023	/* Throw away the ] at the end of the
		3024	collating symbol. */
		3025	PATFETCH (c);
		3026	/* exit from the switch block. */
		3027	continue;
		3028	}
		3029	else
		3030	FREE_STACK_RETURN (REG_ECOLLATE);
		3031	}
		3032	datasize = 1;
		3033	}
		3034	# endif
		3035	/* Throw away the ] at the end of the equivalence
		3036	class (or collating symbol). */
		3037	PATFETCH (c);
		3038
		3039	/* Allocate the space for the equivalence class
		3040	(or collating symbol) (and '\0' if needed). */
		3041	GET_BUFFER_SPACE(datasize);
		3042	/* Update the pointer to indicate end of buffer. */
		3043	b += datasize;
		3044
		3045	if (delim == '=')
		3046	{ /* equivalence class */
		3047	/* Calculate the offset of char_ranges,
		3048	which is next to equivalence_classes. */
		3049	offset = laststart[1] + laststart[2]
		3050	+ laststart[3] +6;
		3051	/* Insert space. */
		3052	insert_space(datasize, laststart + offset, b - 1);
		3053
		3054	/* Write the equivalence_class and \0. */
		3055	for (i = 0 ; i < datasize ; i++)
		3056	laststart[offset + i] = str[i];
		3057
		3058	/* Update the length of equivalence_classes. */
		3059	laststart[3] += datasize;
		3060	had_char_class = true;
		3061	}
		3062	else /* delim == '.' */
		3063	{ /* collating symbol */
		3064	/* Calculate the offset of the equivalence_classes,
		3065	which is next to collating_symbols. */
		3066	offset = laststart[1] + laststart[2] + 6;
		3067	/* Insert space and write the collationg_symbol
		3068	and \0. */
		3069	insert_space(datasize, laststart + offset, b-1);
		3070	for (i = 0 ; i < datasize ; i++)
		3071	laststart[offset + i] = str[i];
		3072
		3073	/* In re_match_2_internal if range_start < -1, we
		3074	assume -range_start is the offset of the
		3075	collating symbol which is specified as
		3076	the character of the range start. So we assign
		3077	-(laststart[1] + laststart[2] + 6) to
		3078	range_start. */
		3079	range_start = -(laststart[1] + laststart[2] + 6);
		3080	/* Update the length of collating_symbol. */
		3081	laststart[2] += datasize;
		3082	had_char_class = false;
		3083	}
		3084	}
		3085	else
		3086	{
		3087	c1++;
		3088	while (c1--)
		3089	PATUNFETCH;
		3090	BUF_PUSH ('[');
		3091	BUF_PUSH (delim);
		3092	laststart[5] += 2; /* Update the length of characters */
		3093	range_start = delim;
		3094	had_char_class = false;
		3095	}
		3096	}
		3097	else
		3098	{
		3099	had_char_class = false;
		3100	BUF_PUSH(c);
		3101	laststart[5]++; /* Update the length of characters */
		3102	range_start = c;
		3103	}
		3104	}
		3105
		3106	#else /* BYTE */
		3107	/* Ensure that we have enough space to push a charset: the
		3108	opcode, the length count, and the bitset; 34 bytes in all. */
		3109	GET_BUFFER_SPACE (34);
		3110
		3111	laststart = b;
		3112
		3113	/* We test `*p == '^' twice, instead of using an if
		3114	statement, so we only need one BUF_PUSH. */
		3115	BUF_PUSH (*p == '^' ? charset_not : charset);
		3116	if (*p == '^')
		3117	p++;
		3118
		3119	/* Remember the first position in the bracket expression. */
		3120	p1 = p;
		3121
		3122	/* Push the number of bytes in the bitmap. */
		3123	BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
		3124
		3125	/* Clear the whole map. */
		3126	bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
		3127
		3128	/* charset_not matches newline according to a syntax bit. */
		3129	if ((re_opcode_t) b[-2] == charset_not
		3130	&& (syntax & RE_HAT_LISTS_NOT_NEWLINE))
		3131	SET_LIST_BIT ('\n');
		3132
		3133	/* Read in characters and ranges, setting map bits. */
		3134	for (;;)
		3135	{
		3136	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3137
		3138	PATFETCH (c);
		3139
		3140	/* \ might escape characters inside [...] and [^...]. */
		3141	if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
		3142	{
		3143	if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
		3144
		3145	PATFETCH (c1);
		3146	SET_LIST_BIT (c1);
		3147	range_start = c1;
		3148	continue;
		3149	}
		3150
		3151	/* Could be the end of the bracket expression. If it's
		3152	not (i.e., when the bracket expression is `[]' so
		3153	far), the ']' character bit gets set way below. */
		3154	if (c == ']' && p != p1 + 1)
		3155	break;
		3156
		3157	/* Look ahead to see if it's a range when the last thing
		3158	was a character class. */
		3159	if (had_char_class && c == '-' && *p != ']')
		3160	FREE_STACK_RETURN (REG_ERANGE);
		3161
		3162	/* Look ahead to see if it's a range when the last thing
		3163	was a character: if this is a hyphen not at the
		3164	beginning or the end of a list, then it's the range
		3165	operator. */
		3166	if (c == '-'
		3167	&& !(p - 2 >= pattern && p[-2] == '[')
		3168	&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
		3169	&& *p != ']')
		3170	{
		3171	reg_errcode_t ret
		3172	= byte_compile_range (range_start, &p, pend, translate,
		3173	syntax, b);
		3174	if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
		3175	range_start = 0xffffffff;
		3176	}
		3177
		3178	else if (p[0] == '-' && p[1] != ']')
		3179	{ /* This handles ranges made up of characters only. */
		3180	reg_errcode_t ret;
		3181
		3182	/* Move past the `-'. */
		3183	PATFETCH (c1);
		3184
		3185	ret = byte_compile_range (c, &p, pend, translate, syntax, b);
		3186	if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
		3187	range_start = 0xffffffff;
		3188	}
		3189
		3190	/* See if we're at the beginning of a possible character
		3191	class. */
		3192
		3193	else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
		3194	{ /* Leave room for the null. */
		3195	char str[CHAR_CLASS_MAX_LENGTH + 1];
		3196
		3197	PATFETCH (c);
		3198	c1 = 0;
		3199
		3200	/* If pattern is `[[:'. */
		3201	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3202
		3203	for (;;)
		3204	{
		3205	PATFETCH (c);
		3206	if ((c == ':' && *p == ']') \|\| p == pend)
		3207	break;
		3208	if (c1 < CHAR_CLASS_MAX_LENGTH)
		3209	str[c1++] = c;
		3210	else
		3211	/* This is in any case an invalid class name. */
		3212	str[0] = '\0';
		3213	}
		3214	str[c1] = '\0';
		3215
		3216	/* If isn't a word bracketed by `[:' and `:]':
		3217	undo the ending character, the letters, and leave
		3218	the leading `:' and `[' (but set bits for them). */
		3219	if (c == ':' && *p == ']')
		3220	{
		3221	# if defined _LIBC \|\| WIDE_CHAR_SUPPORT
		3222	boolean is_lower = STREQ (str, "lower");
		3223	boolean is_upper = STREQ (str, "upper");
		3224	wctype_t wt;
		3225	int ch;
		3226
		3227	wt = IS_CHAR_CLASS (str);
		3228	if (wt == 0)
		3229	FREE_STACK_RETURN (REG_ECTYPE);
		3230
		3231	/* Throw away the ] at the end of the character
		3232	class. */
		3233	PATFETCH (c);
		3234
		3235	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3236
		3237	for (ch = 0; ch < 1 << BYTEWIDTH; ++ch)
		3238	{
		3239	# ifdef _LIBC
		3240	if (__iswctype (__btowc (ch), wt))
		3241	SET_LIST_BIT (ch);
		3242	# else
		3243	if (iswctype (btowc (ch), wt))
		3244	SET_LIST_BIT (ch);
		3245	# endif
		3246
		3247	if (translate && (is_upper \|\| is_lower)
		3248	&& (ISUPPER (ch) \|\| ISLOWER (ch)))
		3249	SET_LIST_BIT (ch);
		3250	}
		3251
		3252	had_char_class = true;
		3253	# else
		3254	int ch;
		3255	boolean is_alnum = STREQ (str, "alnum");
		3256	boolean is_alpha = STREQ (str, "alpha");
		3257	boolean is_blank = STREQ (str, "blank");
		3258	boolean is_cntrl = STREQ (str, "cntrl");
		3259	boolean is_digit = STREQ (str, "digit");
		3260	boolean is_graph = STREQ (str, "graph");
		3261	boolean is_lower = STREQ (str, "lower");
		3262	boolean is_print = STREQ (str, "print");
		3263	boolean is_punct = STREQ (str, "punct");
		3264	boolean is_space = STREQ (str, "space");
		3265	boolean is_upper = STREQ (str, "upper");
		3266	boolean is_xdigit = STREQ (str, "xdigit");
		3267
		3268	if (!IS_CHAR_CLASS (str))
		3269	FREE_STACK_RETURN (REG_ECTYPE);
		3270
		3271	/* Throw away the ] at the end of the character
		3272	class. */
		3273	PATFETCH (c);
		3274
		3275	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3276
		3277	for (ch = 0; ch < 1 << BYTEWIDTH; ch++)
		3278	{
		3279	/* This was split into 3 if's to
		3280	avoid an arbitrary limit in some compiler. */
		3281	if ( (is_alnum && ISALNUM (ch))
		3282	\|\| (is_alpha && ISALPHA (ch))
		3283	\|\| (is_blank && ISBLANK (ch))
		3284	\|\| (is_cntrl && ISCNTRL (ch)))
		3285	SET_LIST_BIT (ch);
		3286	if ( (is_digit && ISDIGIT (ch))
		3287	\|\| (is_graph && ISGRAPH (ch))
		3288	\|\| (is_lower && ISLOWER (ch))
		3289	\|\| (is_print && ISPRINT (ch)))
		3290	SET_LIST_BIT (ch);
		3291	if ( (is_punct && ISPUNCT (ch))
		3292	\|\| (is_space && ISSPACE (ch))
		3293	\|\| (is_upper && ISUPPER (ch))
		3294	\|\| (is_xdigit && ISXDIGIT (ch)))
		3295	SET_LIST_BIT (ch);
		3296	if ( translate && (is_upper \|\| is_lower)
		3297	&& (ISUPPER (ch) \|\| ISLOWER (ch)))
		3298	SET_LIST_BIT (ch);
		3299	}
		3300	had_char_class = true;
		3301	# endif /* libc \|\| wctype.h */
		3302	}
		3303	else
		3304	{
		3305	c1++;
		3306	while (c1--)
		3307	PATUNFETCH;
		3308	SET_LIST_BIT ('[');
		3309	SET_LIST_BIT (':');
		3310	range_start = ':';
		3311	had_char_class = false;
		3312	}
		3313	}
		3314	else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=')
		3315	{
		3316	unsigned char str[MB_LEN_MAX + 1];
		3317	# ifdef _LIBC
		3318	uint32_t nrules =
		3319	_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
		3320	# endif
		3321
		3322	PATFETCH (c);
		3323	c1 = 0;
		3324
		3325	/* If pattern is `[[='. */
		3326	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3327
		3328	for (;;)
		3329	{
		3330	PATFETCH (c);
		3331	if ((c == '=' && *p == ']') \|\| p == pend)
		3332	break;
		3333	if (c1 < MB_LEN_MAX)
		3334	str[c1++] = c;
		3335	else
		3336	/* This is in any case an invalid class name. */
		3337	str[0] = '\0';
		3338	}
		3339	str[c1] = '\0';
		3340
		3341	if (c == '=' && *p == ']' && str[0] != '\0')
		3342	{
		3343	/* If we have no collation data we use the default
		3344	collation in which each character is in a class
		3345	by itself. It also means that ASCII is the
		3346	character set and therefore we cannot have character
		3347	with more than one byte in the multibyte
		3348	representation. */
		3349	# ifdef _LIBC
		3350	if (nrules == 0)
		3351	# endif
		3352	{
		3353	if (c1 != 1)
		3354	FREE_STACK_RETURN (REG_ECOLLATE);
		3355
		3356	/* Throw away the ] at the end of the equivalence
		3357	class. */
		3358	PATFETCH (c);
		3359
		3360	/* Set the bit for the character. */
		3361	SET_LIST_BIT (str[0]);
		3362	}
		3363	# ifdef _LIBC
		3364	else
		3365	{
		3366	/* Try to match the byte sequence in `str' against
		3367	those known to the collate implementation.
		3368	First find out whether the bytes in `str' are
		3369	actually from exactly one character. */
		3370	const int32_t *table;
		3371	const unsigned char *weights;
		3372	const unsigned char *extra;
		3373	const int32_t *indirect;
		3374	int32_t idx;
		3375	const unsigned char *cp = str;
		3376	int ch;
		3377
		3378	/* This #include defines a local function! */
		3379	# include
		3380
		3381	table = (const int32_t *)
		3382	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
		3383	weights = (const unsigned char *)
		3384	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
		3385	extra = (const unsigned char *)
		3386	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
		3387	indirect = (const int32_t *)
		3388	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
		3389
		3390	idx = findidx (&cp);
		3391	if (idx == 0 \|\| cp < str + c1)
		3392	/* This is no valid character. */
		3393	FREE_STACK_RETURN (REG_ECOLLATE);
		3394
		3395	/* Throw away the ] at the end of the equivalence
		3396	class. */
		3397	PATFETCH (c);
		3398
		3399	/* Now we have to go through the whole table
		3400	and find all characters which have the same
		3401	first level weight.
		3402
		3403	XXX Note that this is not entirely correct.
		3404	we would have to match multibyte sequences
		3405	but this is not possible with the current
		3406	implementation. */
		3407	for (ch = 1; ch < 256; ++ch)
		3408	/* XXX This test would have to be changed if we
		3409	would allow matching multibyte sequences. */
		3410	if (table[ch] > 0)
		3411	{
		3412	int32_t idx2 = table[ch];
		3413	size_t len = weights[idx2];
		3414
		3415	/* Test whether the lenghts match. */
		3416	if (weights[idx] == len)
		3417	{
		3418	/* They do. New compare the bytes of
		3419	the weight. */
		3420	size_t cnt = 0;
		3421
		3422	while (cnt < len
		3423	&& (weights[idx + 1 + cnt]
		3424	== weights[idx2 + 1 + cnt]))
		3425	++cnt;
		3426
		3427	if (cnt == len)
		3428	/* They match. Mark the character as
		3429	acceptable. */
		3430	SET_LIST_BIT (ch);
		3431	}
		3432	}
		3433	}
		3434	# endif
		3435	had_char_class = true;
		3436	}
		3437	else
		3438	{
		3439	c1++;
		3440	while (c1--)
		3441	PATUNFETCH;
		3442	SET_LIST_BIT ('[');
		3443	SET_LIST_BIT ('=');
		3444	range_start = '=';
		3445	had_char_class = false;
		3446	}
		3447	}
		3448	else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
		3449	{
		3450	unsigned char str[128]; /* Should be large enough. */
		3451	# ifdef _LIBC
		3452	uint32_t nrules =
		3453	_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
		3454	# endif
		3455
		3456	PATFETCH (c);
		3457	c1 = 0;
		3458
		3459	/* If pattern is `[[.'. */
		3460	if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
		3461
		3462	for (;;)
		3463	{
		3464	PATFETCH (c);
		3465	if ((c == '.' && *p == ']') \|\| p == pend)
		3466	break;
		3467	if (c1 < sizeof (str))
		3468	str[c1++] = c;
		3469	else
		3470	/* This is in any case an invalid class name. */
		3471	str[0] = '\0';
		3472	}
		3473	str[c1] = '\0';
		3474
		3475	if (c == '.' && *p == ']' && str[0] != '\0')
		3476	{
		3477	/* If we have no collation data we use the default
		3478	collation in which each character is the name
		3479	for its own class which contains only the one
		3480	character. It also means that ASCII is the
		3481	character set and therefore we cannot have character
		3482	with more than one byte in the multibyte
		3483	representation. */
		3484	# ifdef _LIBC
		3485	if (nrules == 0)
		3486	# endif
		3487	{
		3488	if (c1 != 1)
		3489	FREE_STACK_RETURN (REG_ECOLLATE);
		3490
		3491	/* Throw away the ] at the end of the equivalence
		3492	class. */
		3493	PATFETCH (c);
		3494
		3495	/* Set the bit for the character. */
		3496	SET_LIST_BIT (str[0]);
		3497	range_start = ((const unsigned char *) str)[0];
		3498	}
		3499	# ifdef _LIBC
		3500	else
		3501	{
		3502	/* Try to match the byte sequence in `str' against
		3503	those known to the collate implementation.
		3504	First find out whether the bytes in `str' are
		3505	actually from exactly one character. */
		3506	int32_t table_size;
		3507	const int32_t *symb_table;
		3508	const unsigned char *extra;
		3509	int32_t idx;
		3510	int32_t elem;
		3511	int32_t second;
		3512	int32_t hash;
		3513
		3514	table_size =
		3515	_NL_CURRENT_WORD (LC_COLLATE,
		3516	_NL_COLLATE_SYMB_HASH_SIZEMB);
		3517	symb_table = (const int32_t *)
		3518	_NL_CURRENT (LC_COLLATE,
		3519	_NL_COLLATE_SYMB_TABLEMB);
		3520	extra = (const unsigned char *)
		3521	_NL_CURRENT (LC_COLLATE,
		3522	_NL_COLLATE_SYMB_EXTRAMB);
		3523
		3524	/* Locate the character in the hashing table. */
		3525	hash = elem_hash (str, c1);
		3526
		3527	idx = 0;
		3528	elem = hash % table_size;
		3529	second = hash % (table_size - 2);
		3530	while (symb_table[2 * elem] != 0)
		3531	{
		3532	/* First compare the hashing value. */
		3533	if (symb_table[2 * elem] == hash
		3534	&& c1 == extra[symb_table[2 * elem + 1]]
		3535	&& memcmp (str,
		3536	&extra[symb_table[2 * elem + 1]
		3537	+ 1],
		3538	c1) == 0)
		3539	{
		3540	/* Yep, this is the entry. */
		3541	idx = symb_table[2 * elem + 1];
		3542	idx += 1 + extra[idx];
		3543	break;
		3544	}
		3545
		3546	/* Next entry. */
		3547	elem += second;
		3548	}
		3549
		3550	if (symb_table[2 * elem] == 0)
		3551	/* This is no valid character. */
		3552	FREE_STACK_RETURN (REG_ECOLLATE);
		3553
		3554	/* Throw away the ] at the end of the equivalence
		3555	class. */
		3556	PATFETCH (c);
		3557
		3558	/* Now add the multibyte character(s) we found
		3559	to the accept list.
		3560
		3561	XXX Note that this is not entirely correct.
		3562	we would have to match multibyte sequences
		3563	but this is not possible with the current
		3564	implementation. Also, we have to match
		3565	collating symbols, which expand to more than
		3566	one file, as a whole and not allow the
		3567	individual bytes. */
		3568	c1 = extra[idx++];
		3569	if (c1 == 1)
		3570	range_start = extra[idx];
		3571	while (c1-- > 0)
		3572	{
		3573	SET_LIST_BIT (extra[idx]);
		3574	++idx;
		3575	}
		3576	}
		3577	# endif
		3578	had_char_class = false;
		3579	}
		3580	else
		3581	{
		3582	c1++;
		3583	while (c1--)
		3584	PATUNFETCH;
		3585	SET_LIST_BIT ('[');
		3586	SET_LIST_BIT ('.');
		3587	range_start = '.';
		3588	had_char_class = false;
		3589	}
		3590	}
		3591	else
		3592	{
		3593	had_char_class = false;
		3594	SET_LIST_BIT (c);
		3595	range_start = c;
		3596	}
		3597	}
		3598
		3599	/* Discard any (non)matching list bytes that are all 0 at the
		3600	end of the map. Decrease the map-length byte too. */
		3601	while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
		3602	b[-1]--;
		3603	b += b[-1];
		3604	#endif /* WCHAR */
		3605	}
		3606	break;
		3607
		3608
		3609	case '(':
		3610	if (syntax & RE_NO_BK_PARENS)
		3611	goto handle_open;
		3612	else
		3613	goto normal_char;
		3614
		3615
		3616	case ')':
		3617	if (syntax & RE_NO_BK_PARENS)
		3618	goto handle_close;
		3619	else
		3620	goto normal_char;
		3621
		3622
		3623	case '\n':
		3624	if (syntax & RE_NEWLINE_ALT)
		3625	goto handle_alt;
		3626	else
		3627	goto normal_char;
		3628
		3629
		3630	case '\|':
		3631	if (syntax & RE_NO_BK_VBAR)
		3632	goto handle_alt;
		3633	else
		3634	goto normal_char;
		3635
		3636
		3637	case '{':
		3638	if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES)
		3639	goto handle_interval;
		3640	else
		3641	goto normal_char;
		3642
		3643
		3644	case '\\':
		3645	if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
		3646
		3647	/* Do not translate the character after the \, so that we can
		3648	distinguish, e.g., \B from \b, even if we normally would
		3649	translate, e.g., B to b. */
		3650	PATFETCH_RAW (c);
		3651
		3652	switch (c)
		3653	{
		3654	case '(':
		3655	if (syntax & RE_NO_BK_PARENS)
		3656	goto normal_backslash;
		3657
		3658	handle_open:
		3659	bufp->re_nsub++;
		3660	regnum++;
		3661
		3662	if (COMPILE_STACK_FULL)
		3663	{
		3664	RETALLOC (compile_stack.stack, compile_stack.size << 1,
		3665	compile_stack_elt_t);
		3666	if (compile_stack.stack == NULL) return REG_ESPACE;
		3667
		3668	compile_stack.size <<= 1;
		3669	}
		3670
		3671	/* These are the values to restore when we hit end of this
		3672	group. They are all relative offsets, so that if the
		3673	whole pattern moves because of realloc, they will still
		3674	be valid. */
		3675	COMPILE_STACK_TOP.begalt_offset = begalt - COMPILED_BUFFER_VAR;
		3676	COMPILE_STACK_TOP.fixup_alt_jump
		3677	= fixup_alt_jump ? fixup_alt_jump - COMPILED_BUFFER_VAR + 1 : 0;
		3678	COMPILE_STACK_TOP.laststart_offset = b - COMPILED_BUFFER_VAR;
		3679	COMPILE_STACK_TOP.regnum = regnum;
		3680
		3681	/* We will eventually replace the 0 with the number of
		3682	groups inner to this one. But do not push a
		3683	start_memory for groups beyond the last one we can
		3684	represent in the compiled pattern. */
		3685	if (regnum <= MAX_REGNUM)
		3686	{
		3687	COMPILE_STACK_TOP.inner_group_offset = b
		3688	- COMPILED_BUFFER_VAR + 2;
		3689	BUF_PUSH_3 (start_memory, regnum, 0);
		3690	}
		3691
		3692	compile_stack.avail++;
		3693
		3694	fixup_alt_jump = 0;
		3695	laststart = 0;
		3696	begalt = b;
		3697	/* If we've reached MAX_REGNUM groups, then this open
		3698	won't actually generate any code, so we'll have to
		3699	clear pending_exact explicitly. */
		3700	pending_exact = 0;
		3701	break;
		3702
		3703
		3704	case ')':
		3705	if (syntax & RE_NO_BK_PARENS) goto normal_backslash;
		3706
		3707	if (COMPILE_STACK_EMPTY)
		3708	{
		3709	if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
		3710	goto normal_backslash;
		3711	else
		3712	FREE_STACK_RETURN (REG_ERPAREN);
		3713	}
		3714
		3715	handle_close:
		3716	if (fixup_alt_jump)
		3717	{ /* Push a dummy failure point at the end of the
		3718	alternative for a possible future
		3719	`pop_failure_jump' to pop. See comments at
		3720	`push_dummy_failure' in `re_match_2'. */
		3721	BUF_PUSH (push_dummy_failure);
		3722
		3723	/* We allocated space for this jump when we assigned
		3724	to `fixup_alt_jump', in the `handle_alt' case below. */
		3725	STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
		3726	}
		3727
		3728	/* See similar code for backslashed left paren above. */
		3729	if (COMPILE_STACK_EMPTY)
		3730	{
		3731	if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
		3732	goto normal_char;
		3733	else
		3734	FREE_STACK_RETURN (REG_ERPAREN);
		3735	}
		3736
		3737	/* Since we just checked for an empty stack above, this
		3738	``can't happen''. */
		3739	assert (compile_stack.avail != 0);
		3740	{
		3741	/* We don't just want to restore into `regnum', because
		3742	later groups should continue to be numbered higher,
		3743	as in `(ab)c(de)' -- the second group is #2. */
		3744	regnum_t this_group_regnum;
		3745
		3746	compile_stack.avail--;
		3747	begalt = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.begalt_offset;
		3748	fixup_alt_jump
		3749	= COMPILE_STACK_TOP.fixup_alt_jump
		3750	? COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.fixup_alt_jump - 1
		3751	: 0;
		3752	laststart = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.laststart_offset;
		3753	this_group_regnum = COMPILE_STACK_TOP.regnum;
		3754	/* If we've reached MAX_REGNUM groups, then this open
		3755	won't actually generate any code, so we'll have to
		3756	clear pending_exact explicitly. */
		3757	pending_exact = 0;
		3758
		3759	/* We're at the end of the group, so now we know how many
		3760	groups were inside this one. */
		3761	if (this_group_regnum <= MAX_REGNUM)
		3762	{
		3763	UCHAR_T *inner_group_loc
		3764	= COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.inner_group_offset;
		3765
		3766	*inner_group_loc = regnum - this_group_regnum;
		3767	BUF_PUSH_3 (stop_memory, this_group_regnum,
		3768	regnum - this_group_regnum);
		3769	}
		3770	}
		3771	break;
		3772
		3773
		3774	case '\|': /* `\\|'. */
		3775	if (syntax & RE_LIMITED_OPS \|\| syntax & RE_NO_BK_VBAR)
		3776	goto normal_backslash;
		3777	handle_alt:
		3778	if (syntax & RE_LIMITED_OPS)
		3779	goto normal_char;
		3780
		3781	/* Insert before the previous alternative a jump which
		3782	jumps to this alternative if the former fails. */
		3783	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		3784	INSERT_JUMP (on_failure_jump, begalt,
		3785	b + 2 + 2 * OFFSET_ADDRESS_SIZE);
		3786	pending_exact = 0;
		3787	b += 1 + OFFSET_ADDRESS_SIZE;
		3788
		3789	/* The alternative before this one has a jump after it
		3790	which gets executed if it gets matched. Adjust that
		3791	jump so it will jump to this alternative's analogous
		3792	jump (put in below, which in turn will jump to the next
		3793	(if any) alternative's such jump, etc.). The last such
		3794	jump jumps to the correct final destination. A picture:
		3795	_____ _____
		3796	\| \| \| \|
		3797	\| v \| v
		3798	a \| b \| c
		3799
		3800	If we are at `b', then fixup_alt_jump right now points to a
		3801	three-byte space after `a'. We'll put in the jump, set
		3802	fixup_alt_jump to right after `b', and leave behind three
		3803	bytes which we'll fill in when we get to after `c'. */
		3804
		3805	if (fixup_alt_jump)
		3806	STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
		3807
		3808	/* Mark and leave space for a jump after this alternative,
		3809	to be filled in later either by next alternative or
		3810	when know we're at the end of a series of alternatives. */
		3811	fixup_alt_jump = b;
		3812	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		3813	b += 1 + OFFSET_ADDRESS_SIZE;
		3814
		3815	laststart = 0;
		3816	begalt = b;
		3817	break;
		3818
		3819
		3820	case '{':
		3821	/* If \{ is a literal. */
		3822	if (!(syntax & RE_INTERVALS)
		3823	/* If we're at `\{' and it's not the open-interval
		3824	operator. */
		3825	\|\| (syntax & RE_NO_BK_BRACES))
		3826	goto normal_backslash;
		3827
		3828	handle_interval:
		3829	{
		3830	/* If got here, then the syntax allows intervals. */
		3831
		3832	/* At least (most) this many matches must be made. */
		3833	int lower_bound = -1, upper_bound = -1;
		3834
		3835	/* Place in the uncompiled pattern (i.e., just after
		3836	the '{') to go back to if the interval is invalid. */
		3837	const CHAR_T *beg_interval = p;
		3838
		3839	if (p == pend)
		3840	goto invalid_interval;
		3841
		3842	GET_UNSIGNED_NUMBER (lower_bound);
		3843
		3844	if (c == ',')
		3845	{
		3846	GET_UNSIGNED_NUMBER (upper_bound);
		3847	if (upper_bound < 0)
		3848	upper_bound = RE_DUP_MAX;
		3849	}
		3850	else
		3851	/* Interval such as `{1}' => match exactly once. */
		3852	upper_bound = lower_bound;
		3853
		3854	if (! (0 <= lower_bound && lower_bound <= upper_bound))
		3855	goto invalid_interval;
		3856
		3857	if (!(syntax & RE_NO_BK_BRACES))
		3858	{
		3859	if (c != '\\' \|\| p == pend)
		3860	goto invalid_interval;
		3861	PATFETCH (c);
		3862	}
		3863
		3864	if (c != '}')
		3865	goto invalid_interval;
		3866
		3867	/* If it's invalid to have no preceding re. */
		3868	if (!laststart)
		3869	{
		3870	if (syntax & RE_CONTEXT_INVALID_OPS
		3871	&& !(syntax & RE_INVALID_INTERVAL_ORD))
		3872	FREE_STACK_RETURN (REG_BADRPT);
		3873	else if (syntax & RE_CONTEXT_INDEP_OPS)
		3874	laststart = b;
		3875	else
		3876	goto unfetch_interval;
		3877	}
		3878
		3879	/* We just parsed a valid interval. */
		3880
		3881	if (RE_DUP_MAX < upper_bound)
		3882	FREE_STACK_RETURN (REG_BADBR);
		3883
		3884	/* If the upper bound is zero, don't want to succeed at
		3885	all; jump from `laststart' to `b + 3', which will be
		3886	the end of the buffer after we insert the jump. */
		3887	/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE'
		3888	instead of 'b + 3'. */
		3889	if (upper_bound == 0)
		3890	{
		3891	GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
		3892	INSERT_JUMP (jump, laststart, b + 1
		3893	+ OFFSET_ADDRESS_SIZE);
		3894	b += 1 + OFFSET_ADDRESS_SIZE;
		3895	}
		3896
		3897	/* Otherwise, we have a nontrivial interval. When
		3898	we're all done, the pattern will look like:
		3899	set_number_at
		3900	set_number_at
		3901	succeed_n
		3902
		3903	jump_n
		3904	(The upper bound and `jump_n' are omitted if
		3905	`upper_bound' is 1, though.) */
		3906	else
		3907	{ /* If the upper bound is > 1, we need to insert
		3908	more at the end of the loop. */
		3909	unsigned nbytes = 2 + 4 * OFFSET_ADDRESS_SIZE +
		3910	(upper_bound > 1) * (2 + 4 * OFFSET_ADDRESS_SIZE);
		3911
		3912	GET_BUFFER_SPACE (nbytes);
		3913
		3914	/* Initialize lower bound of the `succeed_n', even
		3915	though it will be set during matching by its
		3916	attendant `set_number_at' (inserted next),
		3917	because `re_compile_fastmap' needs to know.
		3918	Jump to the `jump_n' we might insert below. */
		3919	INSERT_JUMP2 (succeed_n, laststart,
		3920	b + 1 + 2 * OFFSET_ADDRESS_SIZE
		3921	+ (upper_bound > 1) * (1 + 2 * OFFSET_ADDRESS_SIZE)
		3922	, lower_bound);
		3923	b += 1 + 2 * OFFSET_ADDRESS_SIZE;
		3924
		3925	/* Code to initialize the lower bound. Insert
		3926	before the `succeed_n'. The `5' is the last two
		3927	bytes of this `set_number_at', plus 3 bytes of
		3928	the following `succeed_n'. */
		3929	/* ifdef WCHAR, The '1+2*OFFSET_ADDRESS_SIZE'
		3930	is the 'set_number_at', plus '1+OFFSET_ADDRESS_SIZE'
		3931	of the following `succeed_n'. */
		3932	PREFIX(insert_op2) (set_number_at, laststart, 1
		3933	+ 2 * OFFSET_ADDRESS_SIZE, lower_bound, b);
		3934	b += 1 + 2 * OFFSET_ADDRESS_SIZE;
		3935
		3936	if (upper_bound > 1)
		3937	{ /* More than one repetition is allowed, so
		3938	append a backward jump to the `succeed_n'
		3939	that starts this interval.
		3940
		3941	When we've reached this during matching,
		3942	we'll have matched the interval once, so
		3943	jump back only `upper_bound - 1' times. */
		3944	STORE_JUMP2 (jump_n, b, laststart
		3945	+ 2 * OFFSET_ADDRESS_SIZE + 1,
		3946	upper_bound - 1);
		3947	b += 1 + 2 * OFFSET_ADDRESS_SIZE;
		3948
		3949	/* The location we want to set is the second
		3950	parameter of the `jump_n'; that is `b-2' as
		3951	an absolute address. `laststart' will be
		3952	the `set_number_at' we're about to insert;
		3953	`laststart+3' the number to set, the source
		3954	for the relative address. But we are
		3955	inserting into the middle of the pattern --
		3956	so everything is getting moved up by 5.
		3957	Conclusion: (b - 2) - (laststart + 3) + 5,
		3958	i.e., b - laststart.
		3959
		3960	We insert this at the beginning of the loop
		3961	so that if we fail during matching, we'll
		3962	reinitialize the bounds. */
		3963	PREFIX(insert_op2) (set_number_at, laststart,
		3964	b - laststart,
		3965	upper_bound - 1, b);
		3966	b += 1 + 2 * OFFSET_ADDRESS_SIZE;
		3967	}
		3968	}
		3969	pending_exact = 0;
		3970	break;
		3971
		3972	invalid_interval:
		3973	if (!(syntax & RE_INVALID_INTERVAL_ORD))
		3974	FREE_STACK_RETURN (p == pend ? REG_EBRACE : REG_BADBR);
		3975	unfetch_interval:
		3976	/* Match the characters as literals. */
		3977	p = beg_interval;
		3978	c = '{';
		3979	if (syntax & RE_NO_BK_BRACES)
		3980	goto normal_char;
		3981	else
		3982	goto normal_backslash;
		3983	}
		3984
		3985	#ifdef emacs
		3986	/* There is no way to specify the before_dot and after_dot
		3987	operators. rms says this is ok. --karl */
		3988	case '=':
		3989	BUF_PUSH (at_dot);
		3990	break;
		3991
		3992	case 's':
		3993	laststart = b;
		3994	PATFETCH (c);
		3995	BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
		3996	break;
		3997
		3998	case 'S':
		3999	laststart = b;
		4000	PATFETCH (c);
		4001	BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);
		4002	break;
		4003	#endif /* emacs */
		4004
		4005
		4006	case 'w':
		4007	if (syntax & RE_NO_GNU_OPS)
		4008	goto normal_char;
		4009	laststart = b;
		4010	BUF_PUSH (wordchar);
		4011	break;
		4012
		4013
		4014	case 'W':
		4015	if (syntax & RE_NO_GNU_OPS)
		4016	goto normal_char;
		4017	laststart = b;
		4018	BUF_PUSH (notwordchar);
		4019	break;
		4020
		4021
		4022	case '<':
		4023	if (syntax & RE_NO_GNU_OPS)
		4024	goto normal_char;
		4025	BUF_PUSH (wordbeg);
		4026	break;
		4027
		4028	case '>':
		4029	if (syntax & RE_NO_GNU_OPS)
		4030	goto normal_char;
		4031	BUF_PUSH (wordend);
		4032	break;
		4033
		4034	case 'b':
		4035	if (syntax & RE_NO_GNU_OPS)
		4036	goto normal_char;
		4037	BUF_PUSH (wordbound);
		4038	break;
		4039
		4040	case 'B':
		4041	if (syntax & RE_NO_GNU_OPS)
		4042	goto normal_char;
		4043	BUF_PUSH (notwordbound);
		4044	break;
		4045
		4046	case '`':
		4047	if (syntax & RE_NO_GNU_OPS)
		4048	goto normal_char;
		4049	BUF_PUSH (begbuf);
		4050	break;
		4051
		4052	case '\'':
		4053	if (syntax & RE_NO_GNU_OPS)
		4054	goto normal_char;
		4055	BUF_PUSH (endbuf);
		4056	break;
		4057
		4058	case '1': case '2': case '3': case '4': case '5':
		4059	case '6': case '7': case '8': case '9':
		4060	if (syntax & RE_NO_BK_REFS)
		4061	goto normal_char;
		4062
		4063	c1 = c - '0';
		4064
		4065	if (c1 > regnum)
		4066	FREE_STACK_RETURN (REG_ESUBREG);
		4067
		4068	/* Can't back reference to a subexpression if inside of it. */
		4069	if (group_in_compile_stack (compile_stack, (regnum_t) c1))
		4070	goto normal_char;
		4071
		4072	laststart = b;
		4073	BUF_PUSH_2 (duplicate, c1);
		4074	break;
		4075
		4076
		4077	case '+':
		4078	case '?':
		4079	if (syntax & RE_BK_PLUS_QM)
		4080	goto handle_plus;
		4081	else
		4082	goto normal_backslash;
		4083
		4084	default:
		4085	normal_backslash:
		4086	/* You might think it would be useful for \ to mean
		4087	not to translate; but if we don't translate it
		4088	it will never match anything. */
		4089	c = TRANSLATE (c);
		4090	goto normal_char;
		4091	}
		4092	break;
		4093
		4094
		4095	default:
		4096	/* Expects the character in `c'. */
		4097	normal_char:
		4098	/* If no exactn currently being built. */
		4099	if (!pending_exact
		4100	#ifdef WCHAR
		4101	/* If last exactn handle binary(or character) and
		4102	new exactn handle character(or binary). */
		4103	\|\| is_exactn_bin != is_binary[p - 1 - pattern]
		4104	#endif /* WCHAR */
		4105
		4106	/* If last exactn not at current position. */
		4107	\|\| pending_exact + *pending_exact + 1 != b
		4108
		4109	/* We have only one byte following the exactn for the count. */
		4110	\|\| *pending_exact == (1 << BYTEWIDTH) - 1
		4111
		4112	/* If followed by a repetition operator. */
		4113	\|\| p == '' \|\| *p == '^'
		4114	\|\| ((syntax & RE_BK_PLUS_QM)
		4115	? *p == '\\' && (p[1] == '+' \|\| p[1] == '?')
		4116	: (p == '+' \|\| p == '?'))
		4117	\|\| ((syntax & RE_INTERVALS)
		4118	&& ((syntax & RE_NO_BK_BRACES)
		4119	? *p == '{'
		4120	: (p[0] == '\\' && p[1] == '{'))))
		4121	{
		4122	/* Start building a new exactn. */
		4123
		4124	laststart = b;
		4125
		4126	#ifdef WCHAR
		4127	/* Is this exactn binary data or character? */
		4128	is_exactn_bin = is_binary[p - 1 - pattern];
		4129	if (is_exactn_bin)
		4130	BUF_PUSH_2 (exactn_bin, 0);
		4131	else
		4132	BUF_PUSH_2 (exactn, 0);
		4133	#else
		4134	BUF_PUSH_2 (exactn, 0);
		4135	#endif /* WCHAR */
		4136	pending_exact = b - 1;
		4137	}
		4138
		4139	BUF_PUSH (c);
		4140	(*pending_exact)++;
		4141	break;
		4142	} /* switch (c) */
		4143	} /* while p != pend */
		4144
		4145
		4146	/* Through the pattern now. */
		4147
		4148	if (fixup_alt_jump)
		4149	STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
		4150
		4151	if (!COMPILE_STACK_EMPTY)
		4152	FREE_STACK_RETURN (REG_EPAREN);
		4153
		4154	/* If we don't want backtracking, force success
		4155	the first time we reach the end of the compiled pattern. */
		4156	if (syntax & RE_NO_POSIX_BACKTRACKING)
		4157	BUF_PUSH (succeed);
		4158
		4159	#ifdef WCHAR
		4160	free (pattern);
		4161	free (mbs_offset);
		4162	free (is_binary);
		4163	#endif
		4164	free (compile_stack.stack);
		4165
		4166	/* We have succeeded; set the length of the buffer. */
		4167	#ifdef WCHAR
		4168	bufp->used = (uintptr_t) b - (uintptr_t) COMPILED_BUFFER_VAR;
		4169	#else
		4170	bufp->used = b - bufp->buffer;
		4171	#endif
		4172
		4173	#ifdef DEBUG
		4174	if (debug)
		4175	{
		4176	DEBUG_PRINT1 ("\nCompiled pattern: \n");
		4177	PREFIX(print_compiled_pattern) (bufp);
		4178	}
		4179	#endif /* DEBUG */
		4180
		4181	#ifndef MATCH_MAY_ALLOCATE
		4182	/* Initialize the failure stack to the largest possible stack. This
		4183	isn't necessary unless we're trying to avoid calling alloca in
		4184	the search and match routines. */
		4185	{
		4186	int num_regs = bufp->re_nsub + 1;
		4187
		4188	/* Since DOUBLE_FAIL_STACK refuses to double only if the current size
		4189	is strictly greater than re_max_failures, the largest possible stack
		4190	is 2 * re_max_failures failure points. */
		4191	if (fail_stack.size < (2 * re_max_failures * MAX_FAILURE_ITEMS))
		4192	{
		4193	fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);
		4194
		4195	# ifdef emacs
		4196	if (! fail_stack.stack)
		4197	fail_stack.stack
		4198	= (PREFIX(fail_stack_elt_t) *) xmalloc (fail_stack.size
		4199	* sizeof (PREFIX(fail_stack_elt_t)));
		4200	else
		4201	fail_stack.stack
		4202	= (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
		4203	(fail_stack.size
		4204	* sizeof (PREFIX(fail_stack_elt_t))));
		4205	# else /* not emacs */
		4206	if (! fail_stack.stack)
		4207	fail_stack.stack
		4208	= (PREFIX(fail_stack_elt_t) *) malloc (fail_stack.size
		4209	* sizeof (PREFIX(fail_stack_elt_t)));
		4210	else
		4211	fail_stack.stack
		4212	= (PREFIX(fail_stack_elt_t) *) realloc (fail_stack.stack,
		4213	(fail_stack.size
		4214	* sizeof (PREFIX(fail_stack_elt_t))));
		4215	# endif /* not emacs */
		4216	}
		4217
		4218	PREFIX(regex_grow_registers) (num_regs);
		4219	}
		4220	#endif /* not MATCH_MAY_ALLOCATE */
		4221
		4222	return REG_NOERROR;
		4223	} /* regex_compile */
		4224
		4225	/* Subroutines for `regex_compile'. */
		4226
		4227	/* Store OP at LOC followed by two-byte integer parameter ARG. */
		4228	/* ifdef WCHAR, integer parameter is 1 wchar_t. */
		4229
		4230	static void
		4231	PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg)
		4232	{
		4233	*loc = (UCHAR_T) op;
		4234	STORE_NUMBER (loc + 1, arg);
		4235	}
		4236
		4237
		4238	/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */
		4239	/* ifdef WCHAR, integer parameter is 1 wchar_t. */
		4240
		4241	static void
		4242	PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2)
		4243	{
		4244	*loc = (UCHAR_T) op;
		4245	STORE_NUMBER (loc + 1, arg1);
		4246	STORE_NUMBER (loc + 1 + OFFSET_ADDRESS_SIZE, arg2);
		4247	}
		4248
		4249
		4250	/* Copy the bytes from LOC to END to open up three bytes of space at LOC
		4251	for OP followed by two-byte integer parameter ARG. */
		4252	/* ifdef WCHAR, integer parameter is 1 wchar_t. */
		4253
		4254	static void
		4255	PREFIX(insert_op1) (re_opcode_t op, UCHAR_T loc, int arg, UCHAR_T end)
		4256	{
		4257	register UCHAR_T *pfrom = end;
		4258	register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
		4259
		4260	while (pfrom != loc)
		4261	--pto = --pfrom;
		4262
		4263	PREFIX(store_op1) (op, loc, arg);
		4264	}
		4265
		4266
		4267	/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */
		4268	/* ifdef WCHAR, integer parameter is 1 wchar_t. */
		4269
		4270	static void
		4271	PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1,
		4272	int arg2, UCHAR_T *end)
		4273	{
		4274	register UCHAR_T *pfrom = end;
		4275	register UCHAR_T pto = end + 1 + 2 OFFSET_ADDRESS_SIZE;
		4276
		4277	while (pfrom != loc)
		4278	--pto = --pfrom;
		4279
		4280	PREFIX(store_op2) (op, loc, arg1, arg2);
		4281	}
		4282
		4283
		4284	/* P points to just after a ^ in PATTERN. Return true if that ^ comes
		4285	after an alternative or a begin-subexpression. We assume there is at
		4286	least one character before the ^. */
		4287
		4288	static boolean
		4289	PREFIX(at_begline_loc_p) (const CHAR_T pattern, const CHAR_T p,
		4290	reg_syntax_t syntax)
		4291	{
		4292	const CHAR_T *prev = p - 2;
		4293	boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
		4294
		4295	return
		4296	/* After a subexpression? */
		4297	(*prev == '(' && (syntax & RE_NO_BK_PARENS \|\| prev_prev_backslash))
		4298	/* After an alternative? */
		4299	\|\| (*prev == '\|' && (syntax & RE_NO_BK_VBAR \|\| prev_prev_backslash));
		4300	}
		4301
		4302
		4303	/* The dual of at_begline_loc_p. This one is for $. We assume there is
		4304	at least one character after the $, i.e., `P < PEND'. */
		4305
		4306	static boolean
		4307	PREFIX(at_endline_loc_p) (const CHAR_T p, const CHAR_T pend,
		4308	reg_syntax_t syntax)
		4309	{
		4310	const CHAR_T *next = p;
		4311	boolean next_backslash = *next == '\\';
		4312	const CHAR_T *next_next = p + 1 < pend ? p + 1 : 0;
		4313
		4314	return
		4315	/* Before a subexpression? */
		4316	(syntax & RE_NO_BK_PARENS ? *next == ')'
		4317	: next_backslash && next_next && *next_next == ')')
		4318	/* Before an alternative? */
		4319	\|\| (syntax & RE_NO_BK_VBAR ? *next == '\|'
		4320	: next_backslash && next_next && *next_next == '\|');
		4321	}
		4322
		4323	#else /* not INSIDE_RECURSION */
		4324
		4325	/* Returns true if REGNUM is in one of COMPILE_STACK's elements and
		4326	false if it's not. */
		4327
		4328	static boolean
		4329	group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
		4330	{
		4331	int this_element;
		4332
		4333	for (this_element = compile_stack.avail - 1;
		4334	this_element >= 0;
		4335	this_element--)
		4336	if (compile_stack.stack[this_element].regnum == regnum)
		4337	return true;
		4338
		4339	return false;
		4340	}
		4341	#endif /* not INSIDE_RECURSION */
		4342
		4343	#ifdef INSIDE_RECURSION
		4344
		4345	#ifdef WCHAR
		4346	/* This insert space, which size is "num", into the pattern at "loc".
		4347	"end" must point the end of the allocated buffer. */
		4348	static void
		4349	insert_space (int num, CHAR_T loc, CHAR_T end)
		4350	{
		4351	register CHAR_T *pto = end;
		4352	register CHAR_T *pfrom = end - num;
		4353
		4354	while (pfrom >= loc)
		4355	pto-- = pfrom--;
		4356	}
		4357	#endif /* WCHAR */
		4358
		4359	#ifdef WCHAR
		4360	static reg_errcode_t
		4361	wcs_compile_range (CHAR_T range_start_char, const CHAR_T **p_ptr,
		4362	const CHAR_T *pend, RE_TRANSLATE_TYPE translate,
		4363	reg_syntax_t syntax, CHAR_T b, CHAR_T char_set)
		4364	{
		4365	const CHAR_T p = p_ptr;
		4366	CHAR_T range_start, range_end;
		4367	reg_errcode_t ret;
		4368	# ifdef _LIBC
		4369	uint32_t nrules;
		4370	uint32_t start_val, end_val;
		4371	# endif
		4372	if (p == pend)
		4373	return REG_ERANGE;
		4374
		4375	# ifdef _LIBC
		4376	nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
		4377	if (nrules != 0)
		4378	{
		4379	const char collseq = (const char ) _NL_CURRENT(LC_COLLATE,
		4380	_NL_COLLATE_COLLSEQWC);
		4381	const unsigned char extra = (const unsigned char )
		4382	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
		4383
		4384	if (range_start_char < -1)
		4385	{
		4386	/* range_start is a collating symbol. */
		4387	int32_t *wextra;
		4388	/* Retreive the index and get collation sequence value. */
		4389	wextra = (int32_t*)(extra + char_set[-range_start_char]);
		4390	start_val = wextra[1 + *wextra];
		4391	}
		4392	else
		4393	start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char));
		4394
		4395	end_val = collseq_table_lookup (collseq, TRANSLATE (p[0]));
		4396
		4397	/* Report an error if the range is empty and the syntax prohibits
		4398	this. */
		4399	ret = ((syntax & RE_NO_EMPTY_RANGES)
		4400	&& (start_val > end_val))? REG_ERANGE : REG_NOERROR;
		4401
		4402	/* Insert space to the end of the char_ranges. */
		4403	insert_space(2, b - char_set[5] - 2, b - 1);
		4404	*(b - char_set[5] - 2) = (wchar_t)start_val;
		4405	*(b - char_set[5] - 1) = (wchar_t)end_val;
		4406	char_set[4]++; /* ranges_index */
		4407	}
		4408	else
		4409	# endif
		4410	{
		4411	range_start = (range_start_char >= 0)? TRANSLATE (range_start_char):
		4412	range_start_char;
		4413	range_end = TRANSLATE (p[0]);
		4414	/* Report an error if the range is empty and the syntax prohibits
		4415	this. */
		4416	ret = ((syntax & RE_NO_EMPTY_RANGES)
		4417	&& (range_start > range_end))? REG_ERANGE : REG_NOERROR;
		4418
		4419	/* Insert space to the end of the char_ranges. */
		4420	insert_space(2, b - char_set[5] - 2, b - 1);
		4421	*(b - char_set[5] - 2) = range_start;
		4422	*(b - char_set[5] - 1) = range_end;
		4423	char_set[4]++; /* ranges_index */
		4424	}
		4425	/* Have to increment the pointer into the pattern string, so the
		4426	caller isn't still at the ending character. */
		4427	(*p_ptr)++;
		4428
		4429	return ret;
		4430	}
		4431	#else /* BYTE */
		4432	/* Read the ending character of a range (in a bracket expression) from the
		4433	uncompiled pattern *P_PTR (which ends at PEND). We assume the
		4434	starting character is in `P[-2]'. (`P[-1]' is the character `-'.)
		4435	Then we set the translation of all bits between the starting and
		4436	ending characters (inclusive) in the compiled pattern B.
		4437
		4438	Return an error code.
		4439
		4440	We use these short variable names so we can use the same macros as
		4441	`regex_compile' itself. */
		4442
		4443	static reg_errcode_t
		4444	byte_compile_range (unsigned int range_start_char, const char **p_ptr,
		4445	const char *pend, RE_TRANSLATE_TYPE translate,
		4446	reg_syntax_t syntax, unsigned char *b)
		4447	{
		4448	unsigned this_char;
		4449	const char p = p_ptr;
		4450	reg_errcode_t ret;
		4451	# if _LIBC
		4452	const unsigned char *collseq;
		4453	unsigned int start_colseq;
		4454	unsigned int end_colseq;
		4455	# else
		4456	unsigned end_char;
		4457	# endif
		4458
		4459	if (p == pend)
		4460	return REG_ERANGE;
		4461
		4462	/* Have to increment the pointer into the pattern string, so the
		4463	caller isn't still at the ending character. */
		4464	(*p_ptr)++;
		4465
		4466	/* Report an error if the range is empty and the syntax prohibits this. */
		4467	ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
		4468
		4469	# if _LIBC
		4470	collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE,
		4471	_NL_COLLATE_COLLSEQMB);
		4472
		4473	start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)];
		4474	end_colseq = collseq[(unsigned char) TRANSLATE (p[0])];
		4475	for (this_char = 0; this_char <= (unsigned char) -1; ++this_char)
		4476	{
		4477	unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)];
		4478
		4479	if (start_colseq <= this_colseq && this_colseq <= end_colseq)
		4480	{
		4481	SET_LIST_BIT (TRANSLATE (this_char));
		4482	ret = REG_NOERROR;
		4483	}
		4484	}
		4485	# else
		4486	/* Here we see why `this_char' has to be larger than an `unsigned
		4487	char' -- we would otherwise go into an infinite loop, since all
		4488	characters <= 0xff. */
		4489	range_start_char = TRANSLATE (range_start_char);
		4490	/* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE,
		4491	and some compilers cast it to int implicitly, so following for_loop
		4492	may fall to (almost) infinite loop.
		4493	e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff.
		4494	To avoid this, we cast p[0] to unsigned int and truncate it. */
		4495	end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1));
		4496
		4497	for (this_char = range_start_char; this_char <= end_char; ++this_char)
		4498	{
		4499	SET_LIST_BIT (TRANSLATE (this_char));
		4500	ret = REG_NOERROR;
		4501	}
		4502	# endif
		4503
		4504	return ret;
		4505	}
		4506	#endif /* WCHAR */
		4507
		4508	/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
		4509	BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible
		4510	characters can start a string that matches the pattern. This fastmap
		4511	is used by re_search to skip quickly over impossible starting points.
		4512
		4513	The caller must supply the address of a (1 << BYTEWIDTH)-byte data
		4514	area as BUFP->fastmap.
		4515
		4516	We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
		4517	the pattern buffer.
		4518
		4519	Returns 0 if we succeed, -2 if an internal error. */
		4520
		4521	#ifdef WCHAR
		4522	/* local function for re_compile_fastmap.
		4523	truncate wchar_t character to char. */
		4524	static unsigned char truncate_wchar (CHAR_T c);
		4525
		4526	static unsigned char
		4527	truncate_wchar (CHAR_T c)
		4528	{
		4529	unsigned char buf[MB_CUR_MAX];
		4530	mbstate_t state;
		4531	int retval;
		4532	memset (&state, '\0', sizeof (state));
		4533	# ifdef _LIBC
		4534	retval = __wcrtomb (buf, c, &state);
		4535	# else
		4536	retval = wcrtomb (buf, c, &state);
		4537	# endif
		4538	return retval > 0 ? buf[0] : (unsigned char) c;
		4539	}
		4540	#endif /* WCHAR */
		4541
		4542	static int
		4543	PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp)
		4544	{
		4545	int j, k;
		4546	#ifdef MATCH_MAY_ALLOCATE
		4547	PREFIX(fail_stack_type) fail_stack;
		4548	#endif
		4549	#ifndef REGEX_MALLOC
		4550	char *destination;
		4551	#endif
		4552
		4553	register char *fastmap = bufp->fastmap;
		4554
		4555	#ifdef WCHAR
		4556	/* We need to cast pattern to (wchar_t*), because we casted this compiled
		4557	pattern to (char) in regex_compile. /
		4558	UCHAR_T pattern = (UCHAR_T)bufp->buffer;
		4559	register UCHAR_T pend = (UCHAR_T) (bufp->buffer + bufp->used);
		4560	#else /* BYTE */
		4561	UCHAR_T *pattern = bufp->buffer;
		4562	register UCHAR_T *pend = pattern + bufp->used;
		4563	#endif /* WCHAR */
		4564	UCHAR_T *p = pattern;
		4565
		4566	#ifdef REL_ALLOC
		4567	/* This holds the pointer to the failure stack, when
		4568	it is allocated relocatably. */
		4569	fail_stack_elt_t *failure_stack_ptr;
		4570	#endif
		4571
		4572	/* Assume that each path through the pattern can be null until
		4573	proven otherwise. We set this false at the bottom of switch
		4574	statement, to which we get only if a particular path doesn't
		4575	match the empty string. */
		4576	boolean path_can_be_null = true;
		4577
		4578	/* We aren't doing a `succeed_n' to begin with. */
		4579	boolean succeed_n_p = false;
		4580
		4581	assert (fastmap != NULL && p != NULL);
		4582
		4583	INIT_FAIL_STACK ();
		4584	bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */
		4585	bufp->fastmap_accurate = 1; /* It will be when we're done. */
		4586	bufp->can_be_null = 0;
		4587
		4588	while (1)
		4589	{
		4590	if (p == pend \|\| *p == (UCHAR_T) succeed)
		4591	{
		4592	/* We have reached the (effective) end of pattern. */
		4593	if (!FAIL_STACK_EMPTY ())
		4594	{
		4595	bufp->can_be_null \|= path_can_be_null;
		4596
		4597	/* Reset for next path. */
		4598	path_can_be_null = true;
		4599
		4600	p = fail_stack.stack[--fail_stack.avail].pointer;
		4601
		4602	continue;
		4603	}
		4604	else
		4605	break;
		4606	}
		4607
		4608	/* We should never be about to go beyond the end of the pattern. */
		4609	assert (p < pend);
		4610
		4611	switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
		4612	{
		4613
		4614	/* I guess the idea here is to simply not bother with a fastmap
		4615	if a backreference is used, since it's too hard to figure out
		4616	the fastmap for the corresponding group. Setting
		4617	`can_be_null' stops `re_search_2' from using the fastmap, so
		4618	that is all we do. */
		4619	case duplicate:
		4620	bufp->can_be_null = 1;
		4621	goto done;
		4622
		4623
		4624	/* Following are the cases which match a character. These end
		4625	with `break'. */
		4626
		4627	#ifdef WCHAR
		4628	case exactn:
		4629	fastmap[truncate_wchar(p[1])] = 1;
		4630	break;
		4631	#else /* BYTE */
		4632	case exactn:
		4633	fastmap[p[1]] = 1;
		4634	break;
		4635	#endif /* WCHAR */
		4636	#ifdef MBS_SUPPORT
		4637	case exactn_bin:
		4638	fastmap[p[1]] = 1;
		4639	break;
		4640	#endif
		4641
		4642	#ifdef WCHAR
		4643	/* It is hard to distinguish fastmap from (multi byte) characters
		4644	which depends on current locale. */
		4645	case charset:
		4646	case charset_not:
		4647	case wordchar:
		4648	case notwordchar:
		4649	bufp->can_be_null = 1;
		4650	goto done;
		4651	#else /* BYTE */
		4652	case charset:
		4653	for (j = p++ BYTEWIDTH - 1; j >= 0; j--)
		4654	if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
		4655	fastmap[j] = 1;
		4656	break;
		4657
		4658
		4659	case charset_not:
		4660	/* Chars beyond end of map must be allowed. */
		4661	for (j = p BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
		4662	fastmap[j] = 1;
		4663
		4664	for (j = p++ BYTEWIDTH - 1; j >= 0; j--)
		4665	if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
		4666	fastmap[j] = 1;
		4667	break;
		4668
		4669
		4670	case wordchar:
		4671	for (j = 0; j < (1 << BYTEWIDTH); j++)
		4672	if (SYNTAX (j) == Sword)
		4673	fastmap[j] = 1;
		4674	break;
		4675
		4676
		4677	case notwordchar:
		4678	for (j = 0; j < (1 << BYTEWIDTH); j++)
		4679	if (SYNTAX (j) != Sword)
		4680	fastmap[j] = 1;
		4681	break;
		4682	#endif /* WCHAR */
		4683
		4684	case anychar:
		4685	{
		4686	int fastmap_newline = fastmap['\n'];
		4687
		4688	/* `.' matches anything ... */
		4689	for (j = 0; j < (1 << BYTEWIDTH); j++)
		4690	fastmap[j] = 1;
		4691
		4692	/* ... except perhaps newline. */
		4693	if (!(bufp->syntax & RE_DOT_NEWLINE))
		4694	fastmap['\n'] = fastmap_newline;
		4695
		4696	/* Return if we have already set `can_be_null'; if we have,
		4697	then the fastmap is irrelevant. Something's wrong here. */
		4698	else if (bufp->can_be_null)
		4699	goto done;
		4700
		4701	/* Otherwise, have to check alternative paths. */
		4702	break;
		4703	}
		4704
		4705	#ifdef emacs
		4706	case syntaxspec:
		4707	k = *p++;
		4708	for (j = 0; j < (1 << BYTEWIDTH); j++)
		4709	if (SYNTAX (j) == (enum syntaxcode) k)
		4710	fastmap[j] = 1;
		4711	break;
		4712
		4713
		4714	case notsyntaxspec:
		4715	k = *p++;
		4716	for (j = 0; j < (1 << BYTEWIDTH); j++)
		4717	if (SYNTAX (j) != (enum syntaxcode) k)
		4718	fastmap[j] = 1;
		4719	break;
		4720
		4721
		4722	/* All cases after this match the empty string. These end with
		4723	`continue'. */
		4724
		4725
		4726	case before_dot:
		4727	case at_dot:
		4728	case after_dot:
		4729	continue;
		4730	#endif /* emacs */
		4731
		4732
		4733	case no_op:
		4734	case begline:
		4735	case endline:
		4736	case begbuf:
		4737	case endbuf:
		4738	case wordbound:
		4739	case notwordbound:
		4740	case wordbeg:
		4741	case wordend:
		4742	case push_dummy_failure:
		4743	continue;
		4744
		4745
		4746	case jump_n:
		4747	case pop_failure_jump:
		4748	case maybe_pop_jump:
		4749	case jump:
		4750	case jump_past_alt:
		4751	case dummy_failure_jump:
		4752	EXTRACT_NUMBER_AND_INCR (j, p);
		4753	p += j;
		4754	if (j > 0)
		4755	continue;
		4756
		4757	/* Jump backward implies we just went through the body of a
		4758	loop and matched nothing. Opcode jumped to should be
		4759	`on_failure_jump' or `succeed_n'. Just treat it like an
		4760	ordinary jump. For a * loop, it has pushed its failure
		4761	point already; if so, discard that as redundant. */
		4762	if ((re_opcode_t) *p != on_failure_jump
		4763	&& (re_opcode_t) *p != succeed_n)
		4764	continue;
		4765
		4766	p++;
		4767	EXTRACT_NUMBER_AND_INCR (j, p);
		4768	p += j;
		4769
		4770	/* If what's on the stack is where we are now, pop it. */
		4771	if (!FAIL_STACK_EMPTY ()
		4772	&& fail_stack.stack[fail_stack.avail - 1].pointer == p)
		4773	fail_stack.avail--;
		4774
		4775	continue;
		4776
		4777
		4778	case on_failure_jump:
		4779	case on_failure_keep_string_jump:
		4780	handle_on_failure_jump:
		4781	EXTRACT_NUMBER_AND_INCR (j, p);
		4782
		4783	/* For some patterns, e.g., `(a?)?', `p+j' here points to the
		4784	end of the pattern. We don't want to push such a point,
		4785	since when we restore it above, entering the switch will
		4786	increment `p' past the end of the pattern. We don't need
		4787	to push such a point since we obviously won't find any more
		4788	fastmap entries beyond `pend'. Such a pattern can match
		4789	the null string, though. */
		4790	if (p + j < pend)
		4791	{
		4792	if (!PUSH_PATTERN_OP (p + j, fail_stack))
		4793	{
		4794	RESET_FAIL_STACK ();
		4795	return -2;
		4796	}
		4797	}
		4798	else
		4799	bufp->can_be_null = 1;
		4800
		4801	if (succeed_n_p)
		4802	{
		4803	EXTRACT_NUMBER_AND_INCR (k, p); /* Skip the n. */
		4804	succeed_n_p = false;
		4805	}
		4806
		4807	continue;
		4808
		4809
		4810	case succeed_n:
		4811	/* Get to the number of times to succeed. */
		4812	p += OFFSET_ADDRESS_SIZE;
		4813
		4814	/* Increment p past the n for when k != 0. */
		4815	EXTRACT_NUMBER_AND_INCR (k, p);
		4816	if (k == 0)
		4817	{
		4818	p -= 2 * OFFSET_ADDRESS_SIZE;
		4819	succeed_n_p = true; /* Spaghetti code alert. */
		4820	goto handle_on_failure_jump;
		4821	}
		4822	continue;
		4823
		4824
		4825	case set_number_at:
		4826	p += 2 * OFFSET_ADDRESS_SIZE;
		4827	continue;
		4828
		4829
		4830	case start_memory:
		4831	case stop_memory:
		4832	p += 2;
		4833	continue;
		4834
		4835
		4836	default:
		4837	abort (); /* We have listed all the cases. */
		4838	} /* switch p++ /
		4839
		4840	/* Getting here means we have found the possible starting
		4841	characters for one path of the pattern -- and that the empty
		4842	string does not match. We need not follow this path further.
		4843	Instead, look at the next alternative (remembered on the
		4844	stack), or quit if no more. The test at the top of the loop
		4845	does these things. */
		4846	path_can_be_null = false;
		4847	p = pend;
		4848	} /* while p */
		4849
		4850	/* Set `can_be_null' for the last path (also the first path, if the
		4851	pattern is empty). */
		4852	bufp->can_be_null \|= path_can_be_null;
		4853
		4854	done:
		4855	RESET_FAIL_STACK ();
		4856	return 0;
		4857	}
		4858
		4859	#else /* not INSIDE_RECURSION */
		4860
		4861	int
		4862	re_compile_fastmap (struct re_pattern_buffer *bufp)
		4863	{
		4864	# ifdef MBS_SUPPORT
		4865	if (MB_CUR_MAX != 1)
		4866	return wcs_re_compile_fastmap(bufp);
		4867	else
		4868	# endif
		4869	return byte_re_compile_fastmap(bufp);
		4870	} /* re_compile_fastmap */
		4871	#ifdef _LIBC
		4872	weak_alias (__re_compile_fastmap, re_compile_fastmap)
		4873	#endif
		4874
		4875
		4876	/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
		4877	ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use
		4878	this memory for recording register information. STARTS and ENDS
		4879	must be allocated using the malloc library routine, and must each
		4880	be at least NUM_REGS * sizeof (regoff_t) bytes long.
		4881
		4882	If NUM_REGS == 0, then subsequent matches should allocate their own
		4883	register data.
		4884
		4885	Unless this function is called, the first search or match using
		4886	PATTERN_BUFFER will allocate its own register data, without
		4887	freeing the old data. */
		4888
		4889	void
		4890	re_set_registers (struct re_pattern_buffer *bufp,
		4891	struct re_registers *regs, unsigned num_regs,
		4892	regoff_t starts, regoff_t ends)
		4893	{
		4894	if (num_regs)
		4895	{
		4896	bufp->regs_allocated = REGS_REALLOCATE;
		4897	regs->num_regs = num_regs;
		4898	regs->start = starts;
		4899	regs->end = ends;
		4900	}
		4901	else
		4902	{
		4903	bufp->regs_allocated = REGS_UNALLOCATED;
		4904	regs->num_regs = 0;
		4905	regs->start = regs->end = (regoff_t *) 0;
		4906	}
		4907	}
		4908	#ifdef _LIBC
		4909	weak_alias (__re_set_registers, re_set_registers)
		4910	#endif
		4911
		4912	/* Searching routines. */
		4913
		4914	/* Like re_search_2, below, but only one string is specified, and
		4915	doesn't let you say where to stop matching. */
		4916
		4917	int
		4918	re_search (struct re_pattern_buffer bufp, const char string, int size,
		4919	int startpos, int range, struct re_registers *regs)
		4920	{
		4921	return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
		4922	regs, size);
		4923	}
		4924	#ifdef _LIBC
		4925	weak_alias (__re_search, re_search)
		4926	#endif
		4927
		4928
		4929	/* Using the compiled pattern in BUFP->buffer, first tries to match the
		4930	virtual concatenation of STRING1 and STRING2, starting first at index
		4931	STARTPOS, then at STARTPOS + 1, and so on.
		4932
		4933	STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
		4934
		4935	RANGE is how far to scan while trying to match. RANGE = 0 means try
		4936	only at STARTPOS; in general, the last start tried is STARTPOS +
		4937	RANGE.
		4938
		4939	In REGS, return the indices of the virtual concatenation of STRING1
		4940	and STRING2 that matched the entire BUFP->buffer and its contained
		4941	subexpressions.
		4942
		4943	Do not consider matching one past the index STOP in the virtual
		4944	concatenation of STRING1 and STRING2.
		4945
		4946	We return either the position in the strings at which the match was
		4947	found, -1 if no match, or -2 if error (such as failure
		4948	stack overflow). */
		4949
		4950	int
		4951	re_search_2 (struct re_pattern_buffer bufp, const char string1, int size1,
		4952	const char *string2, int size2, int startpos, int range,
		4953	struct re_registers *regs, int stop)
		4954	{
		4955	# ifdef MBS_SUPPORT
		4956	if (MB_CUR_MAX != 1)
		4957	return wcs_re_search_2 (bufp, string1, size1, string2, size2, startpos,
		4958	range, regs, stop);
		4959	else
		4960	# endif
		4961	return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos,
		4962	range, regs, stop);
		4963	} /* re_search_2 */
		4964	#ifdef _LIBC
		4965	weak_alias (__re_search_2, re_search_2)
		4966	#endif
		4967
		4968	#endif /* not INSIDE_RECURSION */
		4969
		4970	#ifdef INSIDE_RECURSION
		4971
		4972	#ifdef MATCH_MAY_ALLOCATE
		4973	# define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL
		4974	#else
		4975	# define FREE_VAR(var) free (var); var = NULL
		4976	#endif
		4977
		4978	#ifdef WCHAR
		4979	# define MAX_ALLOCA_SIZE 2000
		4980
		4981	# define FREE_WCS_BUFFERS() \
		4982	do { \
		4983	if (size1 > MAX_ALLOCA_SIZE) \
		4984	{ \
		4985	free (wcs_string1); \
		4986	free (mbs_offset1); \
		4987	} \
		4988	else \
		4989	{ \
		4990	FREE_VAR (wcs_string1); \
		4991	FREE_VAR (mbs_offset1); \
		4992	} \
		4993	if (size2 > MAX_ALLOCA_SIZE) \
		4994	{ \
		4995	free (wcs_string2); \
		4996	free (mbs_offset2); \
		4997	} \
		4998	else \
		4999	{ \
		5000	FREE_VAR (wcs_string2); \
		5001	FREE_VAR (mbs_offset2); \
		5002	} \
		5003	} while (0)
		5004
		5005	#endif
		5006
		5007
		5008	static int
		5009	PREFIX(re_search_2) (struct re_pattern_buffer bufp, const char string1,
		5010	int size1, const char *string2, int size2,
		5011	int startpos, int range,
		5012	struct re_registers *regs, int stop)
		5013	{
		5014	int val;
		5015	register char *fastmap = bufp->fastmap;
		5016	register RE_TRANSLATE_TYPE translate = bufp->translate;
		5017	int total_size = size1 + size2;
		5018	int endpos = startpos + range;
		5019	#ifdef WCHAR
		5020	/* We need wchar_t* buffers correspond to cstring1, cstring2. */
		5021	wchar_t wcs_string1 = NULL, wcs_string2 = NULL;
		5022	/* We need the size of wchar_t buffers correspond to csize1, csize2. */
		5023	int wcs_size1 = 0, wcs_size2 = 0;
		5024	/* offset buffer for optimizatoin. See convert_mbs_to_wc. */
		5025	int mbs_offset1 = NULL, mbs_offset2 = NULL;
		5026	/* They hold whether each wchar_t is binary data or not. */
		5027	char *is_binary = NULL;
		5028	#endif /* WCHAR */
		5029
		5030	/* Check for out-of-range STARTPOS. */
		5031	if (startpos < 0 \|\| startpos > total_size)
		5032	return -1;
		5033
		5034	/* Fix up RANGE if it might eventually take us outside
		5035	the virtual concatenation of STRING1 and STRING2.
		5036	Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE. */
		5037	if (endpos < 0)
		5038	range = 0 - startpos;
		5039	else if (endpos > total_size)
		5040	range = total_size - startpos;
		5041
		5042	/* If the search isn't to be a backwards one, don't waste time in a
		5043	search for a pattern that must be anchored. */
		5044	if (bufp->used > 0 && range > 0
		5045	&& ((re_opcode_t) bufp->buffer[0] == begbuf
		5046	/* `begline' is like `begbuf' if it cannot match at newlines. */
		5047	\|\| ((re_opcode_t) bufp->buffer[0] == begline
		5048	&& !bufp->newline_anchor)))
		5049	{
		5050	if (startpos > 0)
		5051	return -1;
		5052	else
		5053	range = 1;
		5054	}
		5055
		5056	#ifdef emacs
		5057	/* In a forward search for something that starts with \=.
		5058	don't keep searching past point. */
		5059	if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0)
		5060	{
		5061	range = PT - startpos;
		5062	if (range <= 0)
		5063	return -1;
		5064	}
		5065	#endif /* emacs */
		5066
		5067	/* Update the fastmap now if not correct already. */
		5068	if (fastmap && !bufp->fastmap_accurate)
		5069	if (re_compile_fastmap (bufp) == -2)
		5070	return -2;
		5071
		5072	#ifdef WCHAR
		5073	/* Allocate wchar_t array for wcs_string1 and wcs_string2 and
		5074	fill them with converted string. */
		5075	if (size1 != 0)
		5076	{
		5077	if (size1 > MAX_ALLOCA_SIZE)
		5078	{
		5079	wcs_string1 = TALLOC (size1 + 1, CHAR_T);
		5080	mbs_offset1 = TALLOC (size1 + 1, int);
		5081	is_binary = TALLOC (size1 + 1, char);
		5082	}
		5083	else
		5084	{
		5085	wcs_string1 = REGEX_TALLOC (size1 + 1, CHAR_T);
		5086	mbs_offset1 = REGEX_TALLOC (size1 + 1, int);
		5087	is_binary = REGEX_TALLOC (size1 + 1, char);
		5088	}
		5089	if (!wcs_string1 \|\| !mbs_offset1 \|\| !is_binary)
		5090	{
		5091	if (size1 > MAX_ALLOCA_SIZE)
		5092	{
		5093	free (wcs_string1);
		5094	free (mbs_offset1);
		5095	free (is_binary);
		5096	}
		5097	else
		5098	{
		5099	FREE_VAR (wcs_string1);
		5100	FREE_VAR (mbs_offset1);
		5101	FREE_VAR (is_binary);
		5102	}
		5103	return -2;
		5104	}
		5105	wcs_size1 = convert_mbs_to_wcs(wcs_string1, string1, size1,
		5106	mbs_offset1, is_binary);
		5107	wcs_string1[wcs_size1] = L'\0'; /* for a sentinel */
		5108	if (size1 > MAX_ALLOCA_SIZE)
		5109	free (is_binary);
		5110	else
		5111	FREE_VAR (is_binary);
		5112	}
		5113	if (size2 != 0)
		5114	{
		5115	if (size2 > MAX_ALLOCA_SIZE)
		5116	{
		5117	wcs_string2 = TALLOC (size2 + 1, CHAR_T);
		5118	mbs_offset2 = TALLOC (size2 + 1, int);
		5119	is_binary = TALLOC (size2 + 1, char);
		5120	}
		5121	else
		5122	{
		5123	wcs_string2 = REGEX_TALLOC (size2 + 1, CHAR_T);
		5124	mbs_offset2 = REGEX_TALLOC (size2 + 1, int);
		5125	is_binary = REGEX_TALLOC (size2 + 1, char);
		5126	}
		5127	if (!wcs_string2 \|\| !mbs_offset2 \|\| !is_binary)
		5128	{
		5129	FREE_WCS_BUFFERS ();
		5130	if (size2 > MAX_ALLOCA_SIZE)
		5131	free (is_binary);
		5132	else
		5133	FREE_VAR (is_binary);
		5134	return -2;
		5135	}
		5136	wcs_size2 = convert_mbs_to_wcs(wcs_string2, string2, size2,
		5137	mbs_offset2, is_binary);
		5138	wcs_string2[wcs_size2] = L'\0'; /* for a sentinel */
		5139	if (size2 > MAX_ALLOCA_SIZE)
		5140	free (is_binary);
		5141	else
		5142	FREE_VAR (is_binary);
		5143	}
		5144	#endif /* WCHAR */
		5145
		5146
		5147	/* Loop through the string, looking for a place to start matching. */
		5148	for (;;)
		5149	{
		5150	/* If a fastmap is supplied, skip quickly over characters that
		5151	cannot be the start of a match. If the pattern can match the
		5152	null string, however, we don't need to skip characters; we want
		5153	the first null string. */
		5154	if (fastmap && startpos < total_size && !bufp->can_be_null)
		5155	{
		5156	if (range > 0) /* Searching forwards. */
		5157	{
		5158	register const char *d;
		5159	register int lim = 0;
		5160	int irange = range;
		5161
		5162	if (startpos < size1 && startpos + range >= size1)
		5163	lim = range - (size1 - startpos);
		5164
		5165	d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
		5166
		5167	/* Written out as an if-else to avoid testing `translate'
		5168	inside the loop. */
		5169	if (translate)
		5170	while (range > lim
		5171	&& !fastmap[(unsigned char)
		5172	translate[(unsigned char) *d++]])
		5173	range--;
		5174	else
		5175	while (range > lim && !fastmap[(unsigned char) *d++])
		5176	range--;
		5177
		5178	startpos += irange - range;
		5179	}
		5180	else /* Searching backwards. */
		5181	{
		5182	register CHAR_T c = (size1 == 0 \|\| startpos >= size1
		5183	? string2[startpos - size1]
		5184	: string1[startpos]);
		5185
		5186	if (!fastmap[(unsigned char) TRANSLATE (c)])
		5187	goto advance;
		5188	}
		5189	}
		5190
		5191	/* If can't match the null string, and that's all we have left, fail. */
		5192	if (range >= 0 && startpos == total_size && fastmap
		5193	&& !bufp->can_be_null)
		5194	{
		5195	#ifdef WCHAR
		5196	FREE_WCS_BUFFERS ();
		5197	#endif
		5198	return -1;
		5199	}
		5200
		5201	#ifdef WCHAR
		5202	val = wcs_re_match_2_internal (bufp, string1, size1, string2,
		5203	size2, startpos, regs, stop,
		5204	wcs_string1, wcs_size1,
		5205	wcs_string2, wcs_size2,
		5206	mbs_offset1, mbs_offset2);
		5207	#else /* BYTE */
		5208	val = byte_re_match_2_internal (bufp, string1, size1, string2,
		5209	size2, startpos, regs, stop);
		5210	#endif /* BYTE */
		5211
		5212	#ifndef REGEX_MALLOC
		5213	# ifdef C_ALLOCA
		5214	alloca (0);
		5215	# endif
		5216	#endif
		5217
		5218	if (val >= 0)
		5219	{
		5220	#ifdef WCHAR
		5221	FREE_WCS_BUFFERS ();
		5222	#endif
		5223	return startpos;
		5224	}
		5225
		5226	if (val == -2)
		5227	{
		5228	#ifdef WCHAR
		5229	FREE_WCS_BUFFERS ();
		5230	#endif
		5231	return -2;
		5232	}
		5233
		5234	advance:
		5235	if (!range)
		5236	break;
		5237	else if (range > 0)
		5238	{
		5239	range--;
		5240	startpos++;
		5241	}
		5242	else
		5243	{
		5244	range++;
		5245	startpos--;
		5246	}
		5247	}
		5248	#ifdef WCHAR
		5249	FREE_WCS_BUFFERS ();
		5250	#endif
		5251	return -1;
		5252	}
		5253
		5254	#ifdef WCHAR
		5255	/* This converts PTR, a pointer into one of the search wchar_t strings
		5256	`string1' and `string2' into an multibyte string offset from the
		5257	beginning of that string. We use mbs_offset to optimize.
		5258	See convert_mbs_to_wcs. */
		5259	# define POINTER_TO_OFFSET(ptr) \
		5260	(FIRST_STRING_P (ptr) \
		5261	? ((regoff_t)(mbs_offset1 != NULL? mbs_offset1[(ptr)-string1] : 0)) \
		5262	: ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0) \
		5263	+ csize1)))
		5264	#else /* BYTE */
		5265	/* This converts PTR, a pointer into one of the search strings `string1'
		5266	and `string2' into an offset from the beginning of that string. */
		5267	# define POINTER_TO_OFFSET(ptr) \
		5268	(FIRST_STRING_P (ptr) \
		5269	? ((regoff_t) ((ptr) - string1)) \
		5270	: ((regoff_t) ((ptr) - string2 + size1)))
		5271	#endif /* WCHAR */
		5272
		5273	/* Macros for dealing with the split strings in re_match_2. */
		5274
		5275	#define MATCHING_IN_FIRST_STRING (dend == end_match_1)
		5276
		5277	/* Call before fetching a character with *d. This switches over to
		5278	string2 if necessary. */
		5279	#define PREFETCH() \
		5280	while (d == dend) \
		5281	{ \
		5282	/* End of string2 => fail. */ \
		5283	if (dend == end_match_2) \
		5284	goto fail; \
		5285	/* End of string1 => advance to string2. */ \
		5286	d = string2; \
		5287	dend = end_match_2; \
		5288	}
		5289
		5290	/* Test if at very beginning or at very end of the virtual concatenation
		5291	of `string1' and `string2'. If only one string, it's `string2'. */
		5292	#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) \|\| !size2)
		5293	#define AT_STRINGS_END(d) ((d) == end2)
		5294
		5295
		5296	/* Test if D points to a character which is word-constituent. We have
		5297	two special cases to check for: if past the end of string1, look at
		5298	the first character in string2; and if before the beginning of
		5299	string2, look at the last character in string1. */
		5300	#ifdef WCHAR
		5301	/* Use internationalized API instead of SYNTAX. */
		5302	# define WORDCHAR_P(d) \
		5303	(iswalnum ((wint_t)((d) == end1 ? *string2 \
		5304	: (d) == string2 - 1 ? (end1 - 1) : (d))) != 0 \
		5305	\|\| ((d) == end1 ? *string2 \
		5306	: (d) == string2 - 1 ? (end1 - 1) : (d)) == L'_')
		5307	#else /* BYTE */
		5308	# define WORDCHAR_P(d) \
		5309	(SYNTAX ((d) == end1 ? *string2 \
		5310	: (d) == string2 - 1 ? (end1 - 1) : (d)) \
		5311	== Sword)
		5312	#endif /* WCHAR */
		5313
		5314	/* Disabled due to a compiler bug -- see comment at case wordbound */
		5315	#if 0
		5316	/* Test if the character before D and the one at D differ with respect
		5317	to being word-constituent. */
		5318	#define AT_WORD_BOUNDARY(d) \
		5319	(AT_STRINGS_BEG (d) \|\| AT_STRINGS_END (d) \
		5320	\|\| WORDCHAR_P (d - 1) != WORDCHAR_P (d))
		5321	#endif
		5322
		5323	/* Free everything we malloc. */
		5324	#ifdef MATCH_MAY_ALLOCATE
		5325	# ifdef WCHAR
		5326	# define FREE_VARIABLES() \
		5327	do { \
		5328	REGEX_FREE_STACK (fail_stack.stack); \
		5329	FREE_VAR (regstart); \
		5330	FREE_VAR (regend); \
		5331	FREE_VAR (old_regstart); \
		5332	FREE_VAR (old_regend); \
		5333	FREE_VAR (best_regstart); \
		5334	FREE_VAR (best_regend); \
		5335	FREE_VAR (reg_info); \
		5336	FREE_VAR (reg_dummy); \
		5337	FREE_VAR (reg_info_dummy); \
		5338	if (!cant_free_wcs_buf) \
		5339	{ \
		5340	FREE_VAR (string1); \
		5341	FREE_VAR (string2); \
		5342	FREE_VAR (mbs_offset1); \
		5343	FREE_VAR (mbs_offset2); \
		5344	} \
		5345	} while (0)
		5346	# else /* BYTE */
		5347	# define FREE_VARIABLES() \
		5348	do { \
		5349	REGEX_FREE_STACK (fail_stack.stack); \
		5350	FREE_VAR (regstart); \
		5351	FREE_VAR (regend); \
		5352	FREE_VAR (old_regstart); \
		5353	FREE_VAR (old_regend); \
		5354	FREE_VAR (best_regstart); \
		5355	FREE_VAR (best_regend); \
		5356	FREE_VAR (reg_info); \
		5357	FREE_VAR (reg_dummy); \
		5358	FREE_VAR (reg_info_dummy); \
		5359	} while (0)
		5360	# endif /* WCHAR */
		5361	#else
		5362	# ifdef WCHAR
		5363	# define FREE_VARIABLES() \
		5364	do { \
		5365	if (!cant_free_wcs_buf) \
		5366	{ \
		5367	FREE_VAR (string1); \
		5368	FREE_VAR (string2); \
		5369	FREE_VAR (mbs_offset1); \
		5370	FREE_VAR (mbs_offset2); \
		5371	} \
		5372	} while (0)
		5373	# else /* BYTE */
		5374	# define FREE_VARIABLES() ((void)0) /* Do nothing! But inhibit gcc warning. */
		5375	# endif /* WCHAR */
		5376	#endif /* not MATCH_MAY_ALLOCATE */
		5377
		5378	/* These values must meet several constraints. They must not be valid
		5379	register values; since we have a limit of 255 registers (because
		5380	we use only one byte in the pattern for the register number), we can
		5381	use numbers larger than 255. They must differ by 1, because of
		5382	NUM_FAILURE_ITEMS above. And the value for the lowest register must
		5383	be larger than the value for the highest register, so we do not try
		5384	to actually save any registers when none are active. */
		5385	#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
		5386	#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)
		5387
		5388	#else /* not INSIDE_RECURSION */
		5389	/* Matching routines. */
		5390
		5391	#ifndef emacs /* Emacs never uses this. */
		5392	/* re_match is like re_match_2 except it takes only a single string. */
		5393
		5394	int
		5395	re_match (struct re_pattern_buffer bufp, const char string,
		5396	int size, int pos, struct re_registers *regs)
		5397	{
		5398	int result;
		5399	# ifdef MBS_SUPPORT
		5400	if (MB_CUR_MAX != 1)
		5401	result = wcs_re_match_2_internal (bufp, NULL, 0, string, size,
		5402	pos, regs, size,
		5403	NULL, 0, NULL, 0, NULL, NULL);
		5404	else
		5405	# endif
		5406	result = byte_re_match_2_internal (bufp, NULL, 0, string, size,
		5407	pos, regs, size);
		5408	# ifndef REGEX_MALLOC
		5409	# ifdef C_ALLOCA
		5410	alloca (0);
		5411	# endif
		5412	# endif
		5413	return result;
		5414	}
		5415	# ifdef _LIBC
		5416	weak_alias (__re_match, re_match)
		5417	# endif
		5418	#endif /* not emacs */
		5419
		5420	#endif /* not INSIDE_RECURSION */
		5421
		5422	#ifdef INSIDE_RECURSION
		5423	static boolean PREFIX(group_match_null_string_p) (UCHAR_T **p,
		5424	UCHAR_T *end,
		5425	PREFIX(register_info_type) *reg_info);
		5426	static boolean PREFIX(alt_match_null_string_p) (UCHAR_T *p,
		5427	UCHAR_T *end,
		5428	PREFIX(register_info_type) *reg_info);
		5429	static boolean PREFIX(common_op_match_null_string_p) (UCHAR_T **p,
		5430	UCHAR_T *end,
		5431	PREFIX(register_info_type) *reg_info);
		5432	static int PREFIX(bcmp_translate) (const CHAR_T s1, const CHAR_T s2,
		5433	int len, char *translate);
		5434	#else /* not INSIDE_RECURSION */
		5435
		5436	/* re_match_2 matches the compiled pattern in BUFP against the
		5437	the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
		5438	and SIZE2, respectively). We start matching at POS, and stop
		5439	matching at STOP.
		5440
		5441	If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
		5442	store offsets for the substring each group matched in REGS. See the
		5443	documentation for exactly how many groups we fill.
		5444
		5445	We return -1 if no match, -2 if an internal error (such as the
		5446	failure stack overflowing). Otherwise, we return the length of the
		5447	matched substring. */
		5448
		5449	int
		5450	re_match_2 (struct re_pattern_buffer bufp, const char string1, int size1,
		5451	const char *string2, int size2, int pos,
		5452	struct re_registers *regs, int stop)
		5453	{
		5454	int result;
		5455	# ifdef MBS_SUPPORT
		5456	if (MB_CUR_MAX != 1)
		5457	result = wcs_re_match_2_internal (bufp, string1, size1, string2, size2,
		5458	pos, regs, stop,
		5459	NULL, 0, NULL, 0, NULL, NULL);
		5460	else
		5461	# endif
		5462	result = byte_re_match_2_internal (bufp, string1, size1, string2, size2,
		5463	pos, regs, stop);
		5464
		5465	#ifndef REGEX_MALLOC
		5466	# ifdef C_ALLOCA
		5467	alloca (0);
		5468	# endif
		5469	#endif
		5470	return result;
		5471	}
		5472	#ifdef _LIBC
		5473	weak_alias (__re_match_2, re_match_2)
		5474	#endif
		5475
		5476	#endif /* not INSIDE_RECURSION */
		5477
		5478	#ifdef INSIDE_RECURSION
		5479
		5480	#ifdef WCHAR
		5481	static int count_mbs_length (int *, int);
		5482
		5483	/* This check the substring (from 0, to length) of the multibyte string,
		5484	to which offset_buffer correspond. And count how many wchar_t_characters
		5485	the substring occupy. We use offset_buffer to optimization.
		5486	See convert_mbs_to_wcs. */
		5487
		5488	static int
		5489	count_mbs_length(int *offset_buffer, int length)
		5490	{
		5491	int upper, lower;
		5492
		5493	/* Check whether the size is valid. */
		5494	if (length < 0)
		5495	return -1;
		5496
		5497	if (offset_buffer == NULL)
		5498	return 0;
		5499
		5500	/* If there are no multibyte character, offset_buffer[i] == i.
		5501	Optmize for this case. */
		5502	if (offset_buffer[length] == length)
		5503	return length;
		5504
		5505	/* Set up upper with length. (because for all i, offset_buffer[i] >= i) */
		5506	upper = length;
		5507	lower = 0;
		5508
		5509	while (true)
		5510	{
		5511	int middle = (lower + upper) / 2;
		5512	if (middle == lower \|\| middle == upper)
		5513	break;
		5514	if (offset_buffer[middle] > length)
		5515	upper = middle;
		5516	else if (offset_buffer[middle] < length)
		5517	lower = middle;
		5518	else
		5519	return middle;
		5520	}
		5521
		5522	return -1;
		5523	}
		5524	#endif /* WCHAR */
		5525
		5526	/* This is a separate function so that we can force an alloca cleanup
		5527	afterwards. */
		5528	#ifdef WCHAR
		5529	static int
		5530	wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
		5531	const char *cstring1, int csize1,
		5532	const char *cstring2, int csize2,
		5533	int pos,
		5534	struct re_registers *regs,
		5535	int stop,
		5536	/* string1 == string2 == NULL means string1/2, size1/2 and
		5537	mbs_offset1/2 need seting up in this function. */
		5538	/* We need wchar_t* buffers correspond to cstring1, cstring2. */
		5539	wchar_t *string1, int size1,
		5540	wchar_t *string2, int size2,
		5541	/* offset buffer for optimizatoin. See convert_mbs_to_wc. */
		5542	int mbs_offset1, int mbs_offset2)
		5543	#else /* BYTE */
		5544	static int
		5545	byte_re_match_2_internal (struct re_pattern_buffer *bufp,
		5546	const char *string1, int size1,
		5547	const char *string2, int size2,
		5548	int pos,
		5549	struct re_registers *regs, int stop)
		5550	#endif /* BYTE */
		5551	{
		5552	/* General temporaries. */
		5553	int mcnt;
		5554	UCHAR_T *p1;
		5555	#ifdef WCHAR
		5556	/* They hold whether each wchar_t is binary data or not. */
		5557	char *is_binary = NULL;
		5558	/* If true, we can't free string1/2, mbs_offset1/2. */
		5559	int cant_free_wcs_buf = 1;
		5560	#endif /* WCHAR */
		5561
		5562	/* Just past the end of the corresponding string. */
		5563	const CHAR_T end1, end2;
		5564
		5565	/* Pointers into string1 and string2, just past the last characters in
		5566	each to consider matching. */
		5567	const CHAR_T end_match_1, end_match_2;
		5568
		5569	/* Where we are in the data, and the end of the current string. */
		5570	const CHAR_T d, dend;
		5571
		5572	/* Where we are in the pattern, and the end of the pattern. */
		5573	#ifdef WCHAR
		5574	UCHAR_T pattern, p;
		5575	register UCHAR_T *pend;
		5576	#else /* BYTE */
		5577	UCHAR_T *p = bufp->buffer;
		5578	register UCHAR_T *pend = p + bufp->used;
		5579	#endif /* WCHAR */
		5580
		5581	/* Mark the opcode just after a start_memory, so we can test for an
		5582	empty subpattern when we get to the stop_memory. */
		5583	UCHAR_T *just_past_start_mem = 0;
		5584
		5585	/* We use this to map every character in the string. */
		5586	RE_TRANSLATE_TYPE translate = bufp->translate;
		5587
		5588	/* Failure point stack. Each place that can handle a failure further
		5589	down the line pushes a failure point on this stack. It consists of
		5590	restart, regend, and reg_info for all registers corresponding to
		5591	the subexpressions we're currently inside, plus the number of such
		5592	registers, and, finally, two char 's. The first char is where
		5593	to resume scanning the pattern; the second one is where to resume
		5594	scanning the strings. If the latter is zero, the failure point is
		5595	a ``dummy''; if a failure happens and the failure point is a dummy,
		5596	it gets discarded and the next next one is tried. */
		5597	#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */
		5598	PREFIX(fail_stack_type) fail_stack;
		5599	#endif
		5600	#ifdef DEBUG
		5601	static unsigned failure_id;
		5602	unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
		5603	#endif
		5604
		5605	#ifdef REL_ALLOC
		5606	/* This holds the pointer to the failure stack, when
		5607	it is allocated relocatably. */
		5608	fail_stack_elt_t *failure_stack_ptr;
		5609	#endif
		5610
		5611	/* We fill all the registers internally, independent of what we
		5612	return, for use in backreferences. The number here includes
		5613	an element for register zero. */
		5614	size_t num_regs = bufp->re_nsub + 1;
		5615
		5616	/* The currently active registers. */
		5617	active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG;
		5618	active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG;
		5619
		5620	/* Information on the contents of registers. These are pointers into
		5621	the input strings; they record just what was matched (on this
		5622	attempt) by a subexpression part of the pattern, that is, the
		5623	regnum-th regstart pointer points to where in the pattern we began
		5624	matching and the regnum-th regend points to right after where we
		5625	stopped matching the regnum-th subexpression. (The zeroth register
		5626	keeps track of what the whole pattern matches.) */
		5627	#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
		5628	const CHAR_T regstart, regend;
		5629	#endif
		5630
		5631	/* If a group that's operated upon by a repetition operator fails to
		5632	match anything, then the register for its start will need to be
		5633	restored because it will have been set to wherever in the string we
		5634	are when we last see its open-group operator. Similarly for a
		5635	register's end. */
		5636	#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
		5637	const CHAR_T old_regstart, old_regend;
		5638	#endif
		5639
		5640	/* The is_active field of reg_info helps us keep track of which (possibly
		5641	nested) subexpressions we are currently in. The matched_something
		5642	field of reg_info[reg_num] helps us tell whether or not we have
		5643	matched any of the pattern so far this time through the reg_num-th
		5644	subexpression. These two fields get reset each time through any
		5645	loop their register is in. */
		5646	#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */
		5647	PREFIX(register_info_type) *reg_info;
		5648	#endif
		5649
		5650	/* The following record the register info as found in the above
		5651	variables when we find a match better than any we've seen before.
		5652	This happens as we backtrack through the failure points, which in
		5653	turn happens only if we have not yet matched the entire string. */
		5654	unsigned best_regs_set = false;
		5655	#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
		5656	const CHAR_T best_regstart, best_regend;
		5657	#endif
		5658
		5659	/* Logically, this is `best_regend[0]'. But we don't want to have to
		5660	allocate space for that if we're not allocating space for anything
		5661	else (see below). Also, we never need info about register 0 for
		5662	any of the other register vectors, and it seems rather a kludge to
		5663	treat `best_regend' differently than the rest. So we keep track of
		5664	the end of the best match so far in a separate variable. We
		5665	initialize this to NULL so that when we backtrack the first time
		5666	and need to test it, it's not garbage. */
		5667	const CHAR_T *match_end = NULL;
		5668
		5669	/* This helps SET_REGS_MATCHED avoid doing redundant work. */
		5670	int set_regs_matched_done = 0;
		5671
		5672	/* Used when we pop values we don't care about. */
		5673	#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
		5674	const CHAR_T **reg_dummy;
		5675	PREFIX(register_info_type) *reg_info_dummy;
		5676	#endif
		5677
		5678	#ifdef DEBUG
		5679	/* Counts the total number of registers pushed. */
		5680	unsigned num_regs_pushed = 0;
		5681	#endif
		5682
		5683	DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");
		5684
		5685	INIT_FAIL_STACK ();
		5686
		5687	#ifdef MATCH_MAY_ALLOCATE
		5688	/* Do not bother to initialize all the register variables if there are
		5689	no groups in the pattern, as it takes a fair amount of time. If
		5690	there are groups, we include space for register 0 (the whole
		5691	pattern), even though we never use it, since it simplifies the
		5692	array indexing. We should fix this. */
		5693	if (bufp->re_nsub)
		5694	{
		5695	regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
		5696	regend = REGEX_TALLOC (num_regs, const CHAR_T *);
		5697	old_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
		5698	old_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
		5699	best_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
		5700	best_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
		5701	reg_info = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
		5702	reg_dummy = REGEX_TALLOC (num_regs, const CHAR_T *);
		5703	reg_info_dummy = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
		5704
		5705	if (!(regstart && regend && old_regstart && old_regend && reg_info
		5706	&& best_regstart && best_regend && reg_dummy && reg_info_dummy))
		5707	{
		5708	FREE_VARIABLES ();
		5709	return -2;
		5710	}
		5711	}
		5712	else
		5713	{
		5714	/* We must initialize all our variables to NULL, so that
		5715	`FREE_VARIABLES' doesn't try to free them. */
		5716	regstart = regend = old_regstart = old_regend = best_regstart
		5717	= best_regend = reg_dummy = NULL;
		5718	reg_info = reg_info_dummy = (PREFIX(register_info_type) *) NULL;
		5719	}
		5720	#endif /* MATCH_MAY_ALLOCATE */
		5721
		5722	/* The starting position is bogus. */
		5723	#ifdef WCHAR
		5724	if (pos < 0 \|\| pos > csize1 + csize2)
		5725	#else /* BYTE */
		5726	if (pos < 0 \|\| pos > size1 + size2)
		5727	#endif
		5728	{
		5729	FREE_VARIABLES ();
		5730	return -1;
		5731	}
		5732
		5733	#ifdef WCHAR
		5734	/* Allocate wchar_t array for string1 and string2 and
		5735	fill them with converted string. */
		5736	if (string1 == NULL && string2 == NULL)
		5737	{
		5738	/* We need seting up buffers here. */
		5739
		5740	/* We must free wcs buffers in this function. */
		5741	cant_free_wcs_buf = 0;
		5742
		5743	if (csize1 != 0)
		5744	{
		5745	string1 = REGEX_TALLOC (csize1 + 1, CHAR_T);
		5746	mbs_offset1 = REGEX_TALLOC (csize1 + 1, int);
		5747	is_binary = REGEX_TALLOC (csize1 + 1, char);
		5748	if (!string1 \|\| !mbs_offset1 \|\| !is_binary)
		5749	{
		5750	FREE_VAR (string1);
		5751	FREE_VAR (mbs_offset1);
		5752	FREE_VAR (is_binary);
		5753	return -2;
		5754	}
		5755	}
		5756	if (csize2 != 0)
		5757	{
		5758	string2 = REGEX_TALLOC (csize2 + 1, CHAR_T);
		5759	mbs_offset2 = REGEX_TALLOC (csize2 + 1, int);
		5760	is_binary = REGEX_TALLOC (csize2 + 1, char);
		5761	if (!string2 \|\| !mbs_offset2 \|\| !is_binary)
		5762	{
		5763	FREE_VAR (string1);
		5764	FREE_VAR (mbs_offset1);
		5765	FREE_VAR (string2);
		5766	FREE_VAR (mbs_offset2);
		5767	FREE_VAR (is_binary);
		5768	return -2;
		5769	}
		5770	size2 = convert_mbs_to_wcs(string2, cstring2, csize2,
		5771	mbs_offset2, is_binary);
		5772	string2[size2] = L'\0'; /* for a sentinel */
		5773	FREE_VAR (is_binary);
		5774	}
		5775	}
		5776
		5777	/* We need to cast pattern to (wchar_t*), because we casted this compiled
		5778	pattern to (char) in regex_compile. /
		5779	p = pattern = (CHAR_T*)bufp->buffer;
		5780	pend = (CHAR_T*)(bufp->buffer + bufp->used);
		5781
		5782	#endif /* WCHAR */
		5783
		5784	/* Initialize subexpression text positions to -1 to mark ones that no
		5785	start_memory/stop_memory has been seen for. Also initialize the
		5786	register information struct. */
		5787	for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
		5788	{
		5789	regstart[mcnt] = regend[mcnt]
		5790	= old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
		5791
		5792	REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
		5793	IS_ACTIVE (reg_info[mcnt]) = 0;
		5794	MATCHED_SOMETHING (reg_info[mcnt]) = 0;
		5795	EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
		5796	}
		5797
		5798	/* We move `string1' into `string2' if the latter's empty -- but not if
		5799	`string1' is null. */
		5800	if (size2 == 0 && string1 != NULL)
		5801	{
		5802	string2 = string1;
		5803	size2 = size1;
		5804	string1 = 0;
		5805	size1 = 0;
		5806	#ifdef WCHAR
		5807	mbs_offset2 = mbs_offset1;
		5808	csize2 = csize1;
		5809	mbs_offset1 = NULL;
		5810	csize1 = 0;
		5811	#endif
		5812	}
		5813	end1 = string1 + size1;
		5814	end2 = string2 + size2;
		5815
		5816	/* Compute where to stop matching, within the two strings. */
		5817	#ifdef WCHAR
		5818	if (stop <= csize1)
		5819	{
		5820	mcnt = count_mbs_length(mbs_offset1, stop);
		5821	end_match_1 = string1 + mcnt;
		5822	end_match_2 = string2;
		5823	}
		5824	else
		5825	{
		5826	if (stop > csize1 + csize2)
		5827	stop = csize1 + csize2;
		5828	end_match_1 = end1;
		5829	mcnt = count_mbs_length(mbs_offset2, stop-csize1);
		5830	end_match_2 = string2 + mcnt;
		5831	}
		5832	if (mcnt < 0)
		5833	{ /* count_mbs_length return error. */
		5834	FREE_VARIABLES ();
		5835	return -1;
		5836	}
		5837	#else
		5838	if (stop <= size1)
		5839	{
		5840	end_match_1 = string1 + stop;
		5841	end_match_2 = string2;
		5842	}
		5843	else
		5844	{
		5845	end_match_1 = end1;
		5846	end_match_2 = string2 + stop - size1;
		5847	}
		5848	#endif /* WCHAR */
		5849
		5850	/* `p' scans through the pattern as `d' scans through the data.
		5851	`dend' is the end of the input string that `d' points within. `d'
		5852	is advanced into the following input string whenever necessary, but
		5853	this happens before fetching; therefore, at the beginning of the
		5854	loop, `d' can be pointing at the end of a string, but it cannot
		5855	equal `string2'. */
		5856	#ifdef WCHAR
		5857	if (size1 > 0 && pos <= csize1)
		5858	{
		5859	mcnt = count_mbs_length(mbs_offset1, pos);
		5860	d = string1 + mcnt;
		5861	dend = end_match_1;
		5862	}
		5863	else
		5864	{
		5865	mcnt = count_mbs_length(mbs_offset2, pos-csize1);
		5866	d = string2 + mcnt;
		5867	dend = end_match_2;
		5868	}
		5869
		5870	if (mcnt < 0)
		5871	{ /* count_mbs_length return error. */
		5872	FREE_VARIABLES ();
		5873	return -1;
		5874	}
		5875	#else
		5876	if (size1 > 0 && pos <= size1)
		5877	{
		5878	d = string1 + pos;
		5879	dend = end_match_1;
		5880	}
		5881	else
		5882	{
		5883	d = string2 + pos - size1;
		5884	dend = end_match_2;
		5885	}
		5886	#endif /* WCHAR */
		5887
		5888	DEBUG_PRINT1 ("The compiled pattern is:\n");
		5889	DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
		5890	DEBUG_PRINT1 ("The string to match is: `");
		5891	DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
		5892	DEBUG_PRINT1 ("'\n");
		5893
		5894	/* This loops over pattern commands. It exits by returning from the
		5895	function if the match is complete, or it drops through if the match
		5896	fails at this starting point in the input data. */
		5897	for (;;)
		5898	{
		5899	#ifdef _LIBC
		5900	DEBUG_PRINT2 ("\n%p: ", p);
		5901	#else
		5902	DEBUG_PRINT2 ("\n0x%x: ", p);
		5903	#endif
		5904
		5905	if (p == pend)
		5906	{ /* End of pattern means we might have succeeded. */
		5907	DEBUG_PRINT1 ("end of pattern ... ");
		5908
		5909	/* If we haven't matched the entire string, and we want the
		5910	longest match, try backtracking. */
		5911	if (d != end_match_2)
		5912	{
		5913	/* 1 if this match ends in the same string (string1 or string2)
		5914	as the best previous match. */
		5915	boolean same_str_p;
		5916
		5917	/* 1 if this match is the best seen so far. */
		5918	boolean best_match_p;
		5919
		5920	same_str_p = (FIRST_STRING_P (match_end)
		5921	== MATCHING_IN_FIRST_STRING);
		5922
		5923	/* AIX compiler got confused when this was combined
		5924	with the previous declaration. */
		5925	if (same_str_p)
		5926	best_match_p = d > match_end;
		5927	else
		5928	best_match_p = !MATCHING_IN_FIRST_STRING;
		5929
		5930	DEBUG_PRINT1 ("backtracking.\n");
		5931
		5932	if (!FAIL_STACK_EMPTY ())
		5933	{ /* More failure points to try. */
		5934
		5935	/* If exceeds best match so far, save it. */
		5936	if (!best_regs_set \|\| best_match_p)
		5937	{
		5938	best_regs_set = true;
		5939	match_end = d;
		5940
		5941	DEBUG_PRINT1 ("\nSAVING match as best so far.\n");
		5942
		5943	for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
		5944	{
		5945	best_regstart[mcnt] = regstart[mcnt];
		5946	best_regend[mcnt] = regend[mcnt];
		5947	}
		5948	}
		5949	goto fail;
		5950	}
		5951
		5952	/* If no failure points, don't restore garbage. And if
		5953	last match is real best match, don't restore second
		5954	best one. */
		5955	else if (best_regs_set && !best_match_p)
		5956	{
		5957	restore_best_regs:
		5958	/* Restore best match. It may happen that `dend ==
		5959	end_match_1' while the restored d is in string2.
		5960	For example, the pattern `x.y.z' against the
		5961	strings `x-' and `y-z-', if the two strings are
		5962	not consecutive in memory. */
		5963	DEBUG_PRINT1 ("Restoring best registers.\n");
		5964
		5965	d = match_end;
		5966	dend = ((d >= string1 && d <= end1)
		5967	? end_match_1 : end_match_2);
		5968
		5969	for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
		5970	{
		5971	regstart[mcnt] = best_regstart[mcnt];
		5972	regend[mcnt] = best_regend[mcnt];
		5973	}
		5974	}
		5975	} /* d != end_match_2 */
		5976
		5977	succeed_label:
		5978	DEBUG_PRINT1 ("Accepting match.\n");
		5979	/* If caller wants register contents data back, do it. */
		5980	if (regs && !bufp->no_sub)
		5981	{
		5982	/* Have the register data arrays been allocated? */
		5983	if (bufp->regs_allocated == REGS_UNALLOCATED)
		5984	{ /* No. So allocate them with malloc. We need one
		5985	extra element beyond `num_regs' for the `-1' marker
		5986	GNU code uses. */
		5987	regs->num_regs = MAX (RE_NREGS, num_regs + 1);
		5988	regs->start = TALLOC (regs->num_regs, regoff_t);
		5989	regs->end = TALLOC (regs->num_regs, regoff_t);
		5990	if (regs->start == NULL \|\| regs->end == NULL)
		5991	{
		5992	FREE_VARIABLES ();
		5993	return -2;
		5994	}
		5995	bufp->regs_allocated = REGS_REALLOCATE;
		5996	}
		5997	else if (bufp->regs_allocated == REGS_REALLOCATE)
		5998	{ /* Yes. If we need more elements than were already
		5999	allocated, reallocate them. If we need fewer, just
		6000	leave it alone. */
		6001	if (regs->num_regs < num_regs + 1)
		6002	{
		6003	regs->num_regs = num_regs + 1;
		6004	RETALLOC (regs->start, regs->num_regs, regoff_t);
		6005	RETALLOC (regs->end, regs->num_regs, regoff_t);
		6006	if (regs->start == NULL \|\| regs->end == NULL)
		6007	{
		6008	FREE_VARIABLES ();
		6009	return -2;
		6010	}
		6011	}
		6012	}
		6013	else
		6014	{
		6015	/* These braces fend off a "empty body in an else-statement"
		6016	warning under GCC when assert expands to nothing. */
		6017	assert (bufp->regs_allocated == REGS_FIXED);
		6018	}
		6019
		6020	/* Convert the pointer data in `regstart' and `regend' to
		6021	indices. Register zero has to be set differently,
		6022	since we haven't kept track of any info for it. */
		6023	if (regs->num_regs > 0)
		6024	{
		6025	regs->start[0] = pos;
		6026	#ifdef WCHAR
		6027	if (MATCHING_IN_FIRST_STRING)
		6028	regs->end[0] = mbs_offset1 != NULL ?
		6029	mbs_offset1[d-string1] : 0;
		6030	else
		6031	regs->end[0] = csize1 + (mbs_offset2 != NULL ?
		6032	mbs_offset2[d-string2] : 0);
		6033	#else
		6034	regs->end[0] = (MATCHING_IN_FIRST_STRING
		6035	? ((regoff_t) (d - string1))
		6036	: ((regoff_t) (d - string2 + size1)));
		6037	#endif /* WCHAR */
		6038	}
		6039
		6040	/* Go through the first `min (num_regs, regs->num_regs)'
		6041	registers, since that is all we initialized. */
		6042	for (mcnt = 1; (unsigned) mcnt < MIN (num_regs, regs->num_regs);
		6043	mcnt++)
		6044	{
		6045	if (REG_UNSET (regstart[mcnt]) \|\| REG_UNSET (regend[mcnt]))
		6046	regs->start[mcnt] = regs->end[mcnt] = -1;
		6047	else
		6048	{
		6049	regs->start[mcnt]
		6050	= (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]);
		6051	regs->end[mcnt]
		6052	= (regoff_t) POINTER_TO_OFFSET (regend[mcnt]);
		6053	}
		6054	}
		6055
		6056	/* If the regs structure we return has more elements than
		6057	were in the pattern, set the extra elements to -1. If
		6058	we (re)allocated the registers, this is the case,
		6059	because we always allocate enough to have at least one
		6060	-1 at the end. */
		6061	for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++)
		6062	regs->start[mcnt] = regs->end[mcnt] = -1;
		6063	} /* regs && !bufp->no_sub */
		6064
		6065	DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",
		6066	nfailure_points_pushed, nfailure_points_popped,
		6067	nfailure_points_pushed - nfailure_points_popped);
		6068	DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);
		6069
		6070	#ifdef WCHAR
		6071	if (MATCHING_IN_FIRST_STRING)
		6072	mcnt = mbs_offset1 != NULL ? mbs_offset1[d-string1] : 0;
		6073	else
		6074	mcnt = (mbs_offset2 != NULL ? mbs_offset2[d-string2] : 0) +
		6075	csize1;
		6076	mcnt -= pos;
		6077	#else
		6078	mcnt = d - pos - (MATCHING_IN_FIRST_STRING
		6079	? string1
		6080	: string2 - size1);
		6081	#endif /* WCHAR */
		6082
		6083	DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);
		6084
		6085	FREE_VARIABLES ();
		6086	return mcnt;
		6087	}
		6088
		6089	/* Otherwise match next pattern command. */
		6090	switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
		6091	{
		6092	/* Ignore these. Used to ignore the n of succeed_n's which
		6093	currently have n == 0. */
		6094	case no_op:
		6095	DEBUG_PRINT1 ("EXECUTING no_op.\n");
		6096	break;
		6097
		6098	case succeed:
		6099	DEBUG_PRINT1 ("EXECUTING succeed.\n");
		6100	goto succeed_label;
		6101
		6102	/* Match the next n pattern characters exactly. The following
		6103	byte in the pattern defines n, and the n bytes after that
		6104	are the characters to match. */
		6105	case exactn:
		6106	#ifdef MBS_SUPPORT
		6107	case exactn_bin:
		6108	#endif
		6109	mcnt = *p++;
		6110	DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);
		6111
		6112	/* This is written out as an if-else so we don't waste time
		6113	testing `translate' inside the loop. */
		6114	if (translate)
		6115	{
		6116	do
		6117	{
		6118	PREFETCH ();
		6119	#ifdef WCHAR
		6120	if (*d <= 0xff)
		6121	{
		6122	if ((UCHAR_T) translate[(unsigned char) *d++]
		6123	!= (UCHAR_T) *p++)
		6124	goto fail;
		6125	}
		6126	else
		6127	{
		6128	if (d++ != (CHAR_T) p++)
		6129	goto fail;
		6130	}
		6131	#else
		6132	if ((UCHAR_T) translate[(unsigned char) *d++]
		6133	!= (UCHAR_T) *p++)
		6134	goto fail;
		6135	#endif /* WCHAR */
		6136	}
		6137	while (--mcnt);
		6138	}
		6139	else
		6140	{
		6141	do
		6142	{
		6143	PREFETCH ();
		6144	if (d++ != (CHAR_T) p++) goto fail;
		6145	}
		6146	while (--mcnt);
		6147	}
		6148	SET_REGS_MATCHED ();
		6149	break;
		6150
		6151
		6152	/* Match any character except possibly a newline or a null. */
		6153	case anychar:
		6154	DEBUG_PRINT1 ("EXECUTING anychar.\n");
		6155
		6156	PREFETCH ();
		6157
		6158	if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n')
		6159	\|\| (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000'))
		6160	goto fail;
		6161
		6162	SET_REGS_MATCHED ();
		6163	DEBUG_PRINT2 (" Matched `%ld'.\n", (long int) *d);
		6164	d++;
		6165	break;
		6166
		6167
		6168	case charset:
		6169	case charset_not:
		6170	{
		6171	register UCHAR_T c;
		6172	#ifdef WCHAR
		6173	unsigned int i, char_class_length, coll_symbol_length,
		6174	equiv_class_length, ranges_length, chars_length, length;
		6175	CHAR_T workp, workp2, *charset_top;
		6176	#define WORK_BUFFER_SIZE 128
		6177	CHAR_T str_buf[WORK_BUFFER_SIZE];
		6178	# ifdef _LIBC
		6179	uint32_t nrules;
		6180	# endif /* _LIBC */
		6181	#endif /* WCHAR */
		6182	boolean negate = (re_opcode_t) *(p - 1) == charset_not;
		6183
		6184	DEBUG_PRINT2 ("EXECUTING charset%s.\n", negate ? "_not" : "");
		6185	PREFETCH ();
		6186	c = TRANSLATE (d); / The character to match. */
		6187	#ifdef WCHAR
		6188	# ifdef _LIBC
		6189	nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
		6190	# endif /* _LIBC */
		6191	charset_top = p - 1;
		6192	char_class_length = *p++;
		6193	coll_symbol_length = *p++;
		6194	equiv_class_length = *p++;
		6195	ranges_length = *p++;
		6196	chars_length = *p++;
		6197	/* p points charset[6], so the address of the next instruction
		6198	(charset[l+m+n+2o+k+p']) equals p[l+m+n+2*o+p'],
		6199	where l=length of char_classes, m=length of collating_symbol,
		6200	n=equivalence_class, o=length of char_range,
		6201	p'=length of character. */
		6202	workp = p;
		6203	/* Update p to indicate the next instruction. */
		6204	p += char_class_length + coll_symbol_length+ equiv_class_length +
		6205	2*ranges_length + chars_length;
		6206
		6207	/* match with char_class? */
		6208	for (i = 0; i < char_class_length ; i += CHAR_CLASS_SIZE)
		6209	{
		6210	wctype_t wctype;
		6211	uintptr_t alignedp = ((uintptr_t)workp
		6212	+ __alignof__(wctype_t) - 1)
		6213	& ~(uintptr_t)(__alignof__(wctype_t) - 1);
		6214	wctype = ((wctype_t)alignedp);
		6215	workp += CHAR_CLASS_SIZE;
		6216	# ifdef _LIBC
		6217	if (__iswctype((wint_t)c, wctype))
		6218	goto char_set_matched;
		6219	# else
		6220	if (iswctype((wint_t)c, wctype))
		6221	goto char_set_matched;
		6222	# endif
		6223	}
		6224
		6225	/* match with collating_symbol? */
		6226	# ifdef _LIBC
		6227	if (nrules != 0)
		6228	{
		6229	const unsigned char extra = (const unsigned char )
		6230	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
		6231
		6232	for (workp2 = workp + coll_symbol_length ; workp < workp2 ;
		6233	workp++)
		6234	{
		6235	int32_t *wextra;
		6236	wextra = (int32_t)(extra + workp++);
		6237	for (i = 0; i < *wextra; ++i)
		6238	if (TRANSLATE(d[i]) != wextra[1 + i])
		6239	break;
		6240
		6241	if (i == *wextra)
		6242	{
		6243	/* Update d, however d will be incremented at
		6244	char_set_matched:, we decrement d here. */
		6245	d += i - 1;
		6246	goto char_set_matched;
		6247	}
		6248	}
		6249	}
		6250	else /* (nrules == 0) */
		6251	# endif
		6252	/* If we can't look up collation data, we use wcscoll
		6253	instead. */
		6254	{
		6255	for (workp2 = workp + coll_symbol_length ; workp < workp2 ;)
		6256	{
		6257	const CHAR_T backup_d = d, backup_dend = dend;
		6258	# ifdef _LIBC
		6259	length = __wcslen (workp);
		6260	# else
		6261	length = wcslen (workp);
		6262	# endif
		6263
		6264	/* If wcscoll(the collating symbol, whole string) > 0,
		6265	any substring of the string never match with the
		6266	collating symbol. */
		6267	# ifdef _LIBC
		6268	if (__wcscoll (workp, d) > 0)
		6269	# else
		6270	if (wcscoll (workp, d) > 0)
		6271	# endif
		6272	{
		6273	workp += length + 1;
		6274	continue;
		6275	}
		6276
		6277	/* First, we compare the collating symbol with
		6278	the first character of the string.
		6279	If it don't match, we add the next character to
		6280	the compare buffer in turn. */
		6281	for (i = 0 ; i < WORK_BUFFER_SIZE-1 ; i++, d++)
		6282	{
		6283	int match;
		6284	if (d == dend)
		6285	{
		6286	if (dend == end_match_2)
		6287	break;
		6288	d = string2;
		6289	dend = end_match_2;
		6290	}
		6291
		6292	/* add next character to the compare buffer. */
		6293	str_buf[i] = TRANSLATE(*d);
		6294	str_buf[i+1] = '\0';
		6295
		6296	# ifdef _LIBC
		6297	match = __wcscoll (workp, str_buf);
		6298	# else
		6299	match = wcscoll (workp, str_buf);
		6300	# endif
		6301	if (match == 0)
		6302	goto char_set_matched;
		6303
		6304	if (match < 0)
		6305	/* (str_buf > workp) indicate (str_buf + X > workp),
		6306	because for all X (str_buf + X > str_buf).
		6307	So we don't need continue this loop. */
		6308	break;
		6309
		6310	/* Otherwise(str_buf < workp),
		6311	(str_buf+next_character) may equals (workp).
		6312	So we continue this loop. */
		6313	}
		6314	/* not matched */
		6315	d = backup_d;
		6316	dend = backup_dend;
		6317	workp += length + 1;
		6318	}
		6319	}
		6320	/* match with equivalence_class? */
		6321	# ifdef _LIBC
		6322	if (nrules != 0)
		6323	{
		6324	const CHAR_T backup_d = d, backup_dend = dend;
		6325	/* Try to match the equivalence class against
		6326	those known to the collate implementation. */
		6327	const int32_t *table;
		6328	const int32_t *weights;
		6329	const int32_t *extra;
		6330	const int32_t *indirect;
		6331	int32_t idx, idx2;
		6332	wint_t *cp;
		6333	size_t len;
		6334
		6335	/* This #include defines a local function! */
		6336	# include
		6337
		6338	table = (const int32_t *)
		6339	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
		6340	weights = (const wint_t *)
		6341	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
		6342	extra = (const wint_t *)
		6343	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
		6344	indirect = (const int32_t *)
		6345	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
		6346
		6347	/* Write 1 collating element to str_buf, and
		6348	get its index. */
		6349	idx2 = 0;
		6350
		6351	for (i = 0 ; idx2 == 0 && i < WORK_BUFFER_SIZE - 1; i++)
		6352	{
		6353	cp = (wint_t*)str_buf;
		6354	if (d == dend)
		6355	{
		6356	if (dend == end_match_2)
		6357	break;
		6358	d = string2;
		6359	dend = end_match_2;
		6360	}
		6361	str_buf[i] = TRANSLATE(*(d+i));
		6362	str_buf[i+1] = '\0'; /* sentinel */
		6363	idx2 = findidx ((const wint_t**)&cp);
		6364	}
		6365
		6366	/* Update d, however d will be incremented at
		6367	char_set_matched:, we decrement d here. */
		6368	d = backup_d + ((wchar_t)cp - (wchar_t)str_buf - 1);
		6369	if (d >= dend)
		6370	{
		6371	if (dend == end_match_2)
		6372	d = dend;
		6373	else
		6374	{
		6375	d = string2;
		6376	dend = end_match_2;
		6377	}
		6378	}
		6379
		6380	len = weights[idx2];
		6381
		6382	for (workp2 = workp + equiv_class_length ; workp < workp2 ;
		6383	workp++)
		6384	{
		6385	idx = (int32_t)*workp;
		6386	/* We already checked idx != 0 in regex_compile. */
		6387
		6388	if (idx2 != 0 && len == weights[idx])
		6389	{
		6390	int cnt = 0;
		6391	while (cnt < len && (weights[idx + 1 + cnt]
		6392	== weights[idx2 + 1 + cnt]))
		6393	++cnt;
		6394
		6395	if (cnt == len)
		6396	goto char_set_matched;
		6397	}
		6398	}
		6399	/* not matched */
		6400	d = backup_d;
		6401	dend = backup_dend;
		6402	}
		6403	else /* (nrules == 0) */
		6404	# endif
		6405	/* If we can't look up collation data, we use wcscoll
		6406	instead. */
		6407	{
		6408	for (workp2 = workp + equiv_class_length ; workp < workp2 ;)
		6409	{
		6410	const CHAR_T backup_d = d, backup_dend = dend;
		6411	# ifdef _LIBC
		6412	length = __wcslen (workp);
		6413	# else
		6414	length = wcslen (workp);
		6415	# endif
		6416
		6417	/* If wcscoll(the collating symbol, whole string) > 0,
		6418	any substring of the string never match with the
		6419	collating symbol. */
		6420	# ifdef _LIBC
		6421	if (__wcscoll (workp, d) > 0)
		6422	# else
		6423	if (wcscoll (workp, d) > 0)
		6424	# endif
		6425	{
		6426	workp += length + 1;
		6427	break;
		6428	}
		6429
		6430	/* First, we compare the equivalence class with
		6431	the first character of the string.
		6432	If it don't match, we add the next character to
		6433	the compare buffer in turn. */
		6434	for (i = 0 ; i < WORK_BUFFER_SIZE - 1 ; i++, d++)
		6435	{
		6436	int match;
		6437	if (d == dend)
		6438	{
		6439	if (dend == end_match_2)
		6440	break;
		6441	d = string2;
		6442	dend = end_match_2;
		6443	}
		6444
		6445	/* add next character to the compare buffer. */
		6446	str_buf[i] = TRANSLATE(*d);
		6447	str_buf[i+1] = '\0';
		6448
		6449	# ifdef _LIBC
		6450	match = __wcscoll (workp, str_buf);
		6451	# else
		6452	match = wcscoll (workp, str_buf);
		6453	# endif
		6454
		6455	if (match == 0)
		6456	goto char_set_matched;
		6457
		6458	if (match < 0)
		6459	/* (str_buf > workp) indicate (str_buf + X > workp),
		6460	because for all X (str_buf + X > str_buf).
		6461	So we don't need continue this loop. */
		6462	break;
		6463
		6464	/* Otherwise(str_buf < workp),
		6465	(str_buf+next_character) may equals (workp).
		6466	So we continue this loop. */
		6467	}
		6468	/* not matched */
		6469	d = backup_d;
		6470	dend = backup_dend;
		6471	workp += length + 1;
		6472	}
		6473	}
		6474
		6475	/* match with char_range? */
		6476	# ifdef _LIBC
		6477	if (nrules != 0)
		6478	{
		6479	uint32_t collseqval;
		6480	const char collseq = (const char )
		6481	_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
		6482
		6483	collseqval = collseq_table_lookup (collseq, c);
		6484
		6485	for (; workp < p - chars_length ;)
		6486	{
		6487	uint32_t start_val, end_val;
		6488
		6489	/* We already compute the collation sequence value
		6490	of the characters (or collating symbols). */
		6491	start_val = (uint32_t) workp++; / range_start */
		6492	end_val = (uint32_t) workp++; / range_end */
		6493
		6494	if (start_val <= collseqval && collseqval <= end_val)
		6495	goto char_set_matched;
		6496	}
		6497	}
		6498	else
		6499	# endif
		6500	{
		6501	/* We set range_start_char at str_buf[0], range_end_char
		6502	at str_buf[4], and compared char at str_buf[2]. */
		6503	str_buf[1] = 0;
		6504	str_buf[2] = c;
		6505	str_buf[3] = 0;
		6506	str_buf[5] = 0;
		6507	for (; workp < p - chars_length ;)
		6508	{
		6509	wchar_t range_start_char, range_end_char;
		6510
		6511	/* match if (range_start_char <= c <= range_end_char). */
		6512
		6513	/* If range_start(or end) < 0, we assume -range_start(end)
		6514	is the offset of the collating symbol which is specified
		6515	as the character of the range start(end). */
		6516
		6517	/* range_start */
		6518	if (*workp < 0)
		6519	range_start_char = charset_top - (*workp++);
		6520	else
		6521	{
		6522	str_buf[0] = *workp++;
		6523	range_start_char = str_buf;
		6524	}
		6525
		6526	/* range_end */
		6527	if (*workp < 0)
		6528	range_end_char = charset_top - (*workp++);
		6529	else
		6530	{
		6531	str_buf[4] = *workp++;
		6532	range_end_char = str_buf + 4;
		6533	}
		6534
		6535	# ifdef _LIBC
		6536	if (__wcscoll (range_start_char, str_buf+2) <= 0
		6537	&& __wcscoll (str_buf+2, range_end_char) <= 0)
		6538	# else
		6539	if (wcscoll (range_start_char, str_buf+2) <= 0
		6540	&& wcscoll (str_buf+2, range_end_char) <= 0)
		6541	# endif
		6542	goto char_set_matched;
		6543	}
		6544	}
		6545
		6546	/* match with char? */
		6547	for (; workp < p ; workp++)
		6548	if (c == *workp)
		6549	goto char_set_matched;
		6550
		6551	negate = !negate;
		6552
		6553	char_set_matched:
		6554	if (negate) goto fail;
		6555	#else
		6556	/* Cast to `unsigned' instead of `unsigned char' in case the
		6557	bit list is a full 32 bytes long. */
		6558	if (c < (unsigned) (p BYTEWIDTH)
		6559	&& p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
		6560	negate = !negate;
		6561
		6562	p += 1 + *p;
		6563
		6564	if (!negate) goto fail;
		6565	#undef WORK_BUFFER_SIZE
		6566	#endif /* WCHAR */
		6567	SET_REGS_MATCHED ();
		6568	d++;
		6569	break;
		6570	}
		6571
		6572
		6573	/* The beginning of a group is represented by start_memory.
		6574	The arguments are the register number in the next byte, and the
		6575	number of groups inner to this one in the next. The text
		6576	matched within the group is recorded (in the internal
		6577	registers data structure) under the register number. */
		6578	case start_memory:
		6579	DEBUG_PRINT3 ("EXECUTING start_memory %ld (%ld):\n",
		6580	(long int) *p, (long int) p[1]);
		6581
		6582	/* Find out if this group can match the empty string. */
		6583	p1 = p; /* To send to group_match_null_string_p. */
		6584
		6585	if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
		6586	REG_MATCH_NULL_STRING_P (reg_info[*p])
		6587	= PREFIX(group_match_null_string_p) (&p1, pend, reg_info);
		6588
		6589	/* Save the position in the string where we were the last time
		6590	we were at this open-group operator in case the group is
		6591	operated upon by a repetition operator, e.g., with `(a)b'
		6592	against `ab'; then we want to ignore where we are now in
		6593	the string in case this attempt to match fails. */
		6594	old_regstart[p] = REG_MATCH_NULL_STRING_P (reg_info[p])
		6595	? REG_UNSET (regstart[p]) ? d : regstart[p]
		6596	: regstart[*p];
		6597	DEBUG_PRINT2 (" old_regstart: %d\n",
		6598	POINTER_TO_OFFSET (old_regstart[*p]));
		6599
		6600	regstart[*p] = d;
		6601	DEBUG_PRINT2 (" regstart: %d\n", POINTER_TO_OFFSET (regstart[*p]));
		6602
		6603	IS_ACTIVE (reg_info[*p]) = 1;
		6604	MATCHED_SOMETHING (reg_info[*p]) = 0;
		6605
		6606	/* Clear this whenever we change the register activity status. */
		6607	set_regs_matched_done = 0;
		6608
		6609	/* This is the new highest active register. */
		6610	highest_active_reg = *p;
		6611
		6612	/* If nothing was active before, this is the new lowest active
		6613	register. */
		6614	if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
		6615	lowest_active_reg = *p;
		6616
		6617	/* Move past the register number and inner group count. */
		6618	p += 2;
		6619	just_past_start_mem = p;
		6620
		6621	break;
		6622
		6623
		6624	/* The stop_memory opcode represents the end of a group. Its
		6625	arguments are the same as start_memory's: the register
		6626	number, and the number of inner groups. */
		6627	case stop_memory:
		6628	DEBUG_PRINT3 ("EXECUTING stop_memory %ld (%ld):\n",
		6629	(long int) *p, (long int) p[1]);
		6630
		6631	/* We need to save the string position the last time we were at
		6632	this close-group operator in case the group is operated
		6633	upon by a repetition operator, e.g., with `((a)(b))*'
		6634	against `aba'; then we want to ignore where we are now in
		6635	the string in case this attempt to match fails. */
		6636	old_regend[p] = REG_MATCH_NULL_STRING_P (reg_info[p])
		6637	? REG_UNSET (regend[p]) ? d : regend[p]
		6638	: regend[*p];
		6639	DEBUG_PRINT2 (" old_regend: %d\n",
		6640	POINTER_TO_OFFSET (old_regend[*p]));
		6641
		6642	regend[*p] = d;
		6643	DEBUG_PRINT2 (" regend: %d\n", POINTER_TO_OFFSET (regend[*p]));
		6644
		6645	/* This register isn't active anymore. */
		6646	IS_ACTIVE (reg_info[*p]) = 0;
		6647
		6648	/* Clear this whenever we change the register activity status. */
		6649	set_regs_matched_done = 0;
		6650
		6651	/* If this was the only register active, nothing is active
		6652	anymore. */
		6653	if (lowest_active_reg == highest_active_reg)
		6654	{
		6655	lowest_active_reg = NO_LOWEST_ACTIVE_REG;
		6656	highest_active_reg = NO_HIGHEST_ACTIVE_REG;
		6657	}
		6658	else
		6659	{ /* We must scan for the new highest active register, since
		6660	it isn't necessarily one less than now: consider
		6661	(a(b)c(d(e)f)g). When group 3 ends, after the f), the
		6662	new highest active register is 1. */
		6663	UCHAR_T r = *p - 1;
		6664	while (r > 0 && !IS_ACTIVE (reg_info[r]))
		6665	r--;
		6666
		6667	/* If we end up at register zero, that means that we saved
		6668	the registers as the result of an `on_failure_jump', not
		6669	a `start_memory', and we jumped to past the innermost
		6670	`stop_memory'. For example, in ((.)*) we save
		6671	registers 1 and 2 as a result of the *, but when we pop
		6672	back to the second ), we are at the stop_memory 1.
		6673	Thus, nothing is active. */
		6674	if (r == 0)
		6675	{
		6676	lowest_active_reg = NO_LOWEST_ACTIVE_REG;
		6677	highest_active_reg = NO_HIGHEST_ACTIVE_REG;
		6678	}
		6679	else
		6680	highest_active_reg = r;
		6681	}
		6682
		6683	/* If just failed to match something this time around with a
		6684	group that's operated on by a repetition operator, try to
		6685	force exit from the ``loop'', and restore the register
		6686	information for this group that we had before trying this
		6687	last match. */
		6688	if ((!MATCHED_SOMETHING (reg_info[*p])
		6689	\|\| just_past_start_mem == p - 1)
		6690	&& (p + 2) < pend)
		6691	{
		6692	boolean is_a_jump_n = false;
		6693
		6694	p1 = p + 2;
		6695	mcnt = 0;
		6696	switch ((re_opcode_t) *p1++)
		6697	{
		6698	case jump_n:
		6699	is_a_jump_n = true;
		6700	case pop_failure_jump:
		6701	case maybe_pop_jump:
		6702	case jump:
		6703	case dummy_failure_jump:
		6704	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		6705	if (is_a_jump_n)
		6706	p1 += OFFSET_ADDRESS_SIZE;
		6707	break;
		6708
		6709	default:
		6710	/* do nothing */ ;
		6711	}
		6712	p1 += mcnt;
		6713
		6714	/* If the next operation is a jump backwards in the pattern
		6715	to an on_failure_jump right before the start_memory
		6716	corresponding to this stop_memory, exit from the loop
		6717	by forcing a failure after pushing on the stack the
		6718	on_failure_jump's jump in the pattern, and d. */
		6719	if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump
		6720	&& (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == start_memory
		6721	&& p1[2+OFFSET_ADDRESS_SIZE] == *p)
		6722	{
		6723	/* If this group ever matched anything, then restore
		6724	what its registers were before trying this last
		6725	failed match, e.g., with `(a)b' against `ab' for
		6726	regstart[1], and, e.g., with `((a)(b))*'
		6727	against `aba' for regend[3].
		6728
		6729	Also restore the registers for inner groups for,
		6730	e.g., `((a)(b))*' against `aba' (register 3 would
		6731	otherwise get trashed). */
		6732
		6733	if (EVER_MATCHED_SOMETHING (reg_info[*p]))
		6734	{
		6735	unsigned r;
		6736
		6737	EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;
		6738
		6739	/* Restore this and inner groups' (if any) registers. */
		6740	for (r = p; r < (unsigned) p + (unsigned) *(p + 1);
		6741	r++)
		6742	{
		6743	regstart[r] = old_regstart[r];
		6744
		6745	/* xx why this test? */
		6746	if (old_regend[r] >= regstart[r])
		6747	regend[r] = old_regend[r];
		6748	}
		6749	}
		6750	p1++;
		6751	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		6752	PUSH_FAILURE_POINT (p1 + mcnt, d, -2);
		6753
		6754	goto fail;
		6755	}
		6756	}
		6757
		6758	/* Move past the register number and the inner group count. */
		6759	p += 2;
		6760	break;
		6761
		6762
		6763	/* \ has been turned into a `duplicate' command which is
		6764	followed by the numeric value of as the register number. */
		6765	case duplicate:
		6766	{
		6767	register const CHAR_T d2, dend2;
		6768	int regno = p++; / Get which register to match against. */
		6769	DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
		6770
		6771	/* Can't back reference a group which we've never matched. */
		6772	if (REG_UNSET (regstart[regno]) \|\| REG_UNSET (regend[regno]))
		6773	goto fail;
		6774
		6775	/* Where in input to try to start matching. */
		6776	d2 = regstart[regno];
		6777
		6778	/* Where to stop matching; if both the place to start and
		6779	the place to stop matching are in the same string, then
		6780	set to the place to stop, otherwise, for now have to use
		6781	the end of the first string. */
		6782
		6783	dend2 = ((FIRST_STRING_P (regstart[regno])
		6784	== FIRST_STRING_P (regend[regno]))
		6785	? regend[regno] : end_match_1);
		6786	for (;;)
		6787	{
		6788	/* If necessary, advance to next segment in register
		6789	contents. */
		6790	while (d2 == dend2)
		6791	{
		6792	if (dend2 == end_match_2) break;
		6793	if (dend2 == regend[regno]) break;
		6794
		6795	/* End of string1 => advance to string2. */
		6796	d2 = string2;
		6797	dend2 = regend[regno];
		6798	}
		6799	/* At end of register contents => success */
		6800	if (d2 == dend2) break;
		6801
		6802	/* If necessary, advance to next segment in data. */
		6803	PREFETCH ();
		6804
		6805	/* How many characters left in this segment to match. */
		6806	mcnt = dend - d;
		6807
		6808	/* Want how many consecutive characters we can match in
		6809	one shot, so, if necessary, adjust the count. */
		6810	if (mcnt > dend2 - d2)
		6811	mcnt = dend2 - d2;
		6812
		6813	/* Compare that many; failure if mismatch, else move
		6814	past them. */
		6815	if (translate
		6816	? PREFIX(bcmp_translate) (d, d2, mcnt, translate)
		6817	: memcmp (d, d2, mcnt*sizeof(UCHAR_T)))
		6818	goto fail;
		6819	d += mcnt, d2 += mcnt;
		6820
		6821	/* Do this because we've match some characters. */
		6822	SET_REGS_MATCHED ();
		6823	}
		6824	}
		6825	break;
		6826
		6827
		6828	/* begline matches the empty string at the beginning of the string
		6829	(unless `not_bol' is set in `bufp'), and, if
		6830	`newline_anchor' is set, after newlines. */
		6831	case begline:
		6832	DEBUG_PRINT1 ("EXECUTING begline.\n");
		6833
		6834	if (AT_STRINGS_BEG (d))
		6835	{
		6836	if (!bufp->not_bol) break;
		6837	}
		6838	else if (d[-1] == '\n' && bufp->newline_anchor)
		6839	{
		6840	break;
		6841	}
		6842	/* In all other cases, we fail. */
		6843	goto fail;
		6844
		6845
		6846	/* endline is the dual of begline. */
		6847	case endline:
		6848	DEBUG_PRINT1 ("EXECUTING endline.\n");
		6849
		6850	if (AT_STRINGS_END (d))
		6851	{
		6852	if (!bufp->not_eol) break;
		6853	}
		6854
		6855	/* We have to ``prefetch'' the next character. */
		6856	else if ((d == end1 ? string2 : d) == '\n'
		6857	&& bufp->newline_anchor)
		6858	{
		6859	break;
		6860	}
		6861	goto fail;
		6862
		6863
		6864	/* Match at the very beginning of the data. */
		6865	case begbuf:
		6866	DEBUG_PRINT1 ("EXECUTING begbuf.\n");
		6867	if (AT_STRINGS_BEG (d))
		6868	break;
		6869	goto fail;
		6870
		6871
		6872	/* Match at the very end of the data. */
		6873	case endbuf:
		6874	DEBUG_PRINT1 ("EXECUTING endbuf.\n");
		6875	if (AT_STRINGS_END (d))
		6876	break;
		6877	goto fail;
		6878
		6879
		6880	/* on_failure_keep_string_jump is used to optimize `.*\n'. It
		6881	pushes NULL as the value for the string on the stack. Then
		6882	`pop_failure_point' will keep the current value for the
		6883	string, instead of restoring it. To see why, consider
		6884	matching `foo\nbar' against `.\n'. The . matches the foo;
		6885	then the . fails against the \n. But the next thing we want
		6886	to do is match the \n against the \n; if we restored the
		6887	string value, we would be back at the foo.
		6888
		6889	Because this is used only in specific cases, we don't need to
		6890	check all the things that `on_failure_jump' does, to make
		6891	sure the right things get saved on the stack. Hence we don't
		6892	share its code. The only reason to push anything on the
		6893	stack at all is that otherwise we would have to change
		6894	`anychar's code to do something besides goto fail in this
		6895	case; that seems worse than this. */
		6896	case on_failure_keep_string_jump:
		6897	DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");
		6898
		6899	EXTRACT_NUMBER_AND_INCR (mcnt, p);
		6900	#ifdef _LIBC
		6901	DEBUG_PRINT3 (" %d (to %p):\n", mcnt, p + mcnt);
		6902	#else
		6903	DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);
		6904	#endif
		6905
		6906	PUSH_FAILURE_POINT (p + mcnt, NULL, -2);
		6907	break;
		6908
		6909
		6910	/* Uses of on_failure_jump:
		6911
		6912	Each alternative starts with an on_failure_jump that points
		6913	to the beginning of the next alternative. Each alternative
		6914	except the last ends with a jump that in effect jumps past
		6915	the rest of the alternatives. (They really jump to the
		6916	ending jump of the following alternative, because tensioning
		6917	these jumps is a hassle.)
		6918
		6919	Repeats start with an on_failure_jump that points past both
		6920	the repetition text and either the following jump or
		6921	pop_failure_jump back to this on_failure_jump. */
		6922	case on_failure_jump:
		6923	on_failure:
		6924	DEBUG_PRINT1 ("EXECUTING on_failure_jump");
		6925
		6926	EXTRACT_NUMBER_AND_INCR (mcnt, p);
		6927	#ifdef _LIBC
		6928	DEBUG_PRINT3 (" %d (to %p)", mcnt, p + mcnt);
		6929	#else
		6930	DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);
		6931	#endif
		6932
		6933	/* If this on_failure_jump comes right before a group (i.e.,
		6934	the original * applied to a group), save the information
		6935	for that group and all inner ones, so that if we fail back
		6936	to this point, the group's information will be correct.
		6937	For example, in $a$\1, we need the preceding group,
		6938	and in $zz\(a$b\)\2, we need the inner group. */
		6939
		6940	/* We can't use `p' to check ahead because we push
		6941	a failure point to `p + mcnt' after we do this. */
		6942	p1 = p;
		6943
		6944	/* We need to skip no_op's before we look for the
		6945	start_memory in case this on_failure_jump is happening as
		6946	the result of a completed succeed_n, as in $a$\{1,3\}b\1
		6947	against aba. */
		6948	while (p1 < pend && (re_opcode_t) *p1 == no_op)
		6949	p1++;
		6950
		6951	if (p1 < pend && (re_opcode_t) *p1 == start_memory)
		6952	{
		6953	/* We have a new highest active register now. This will
		6954	get reset at the start_memory we are about to get to,
		6955	but we will have saved all the registers relevant to
		6956	this repetition op, as described above. */
		6957	highest_active_reg = (p1 + 1) + (p1 + 2);
		6958	if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
		6959	lowest_active_reg = *(p1 + 1);
		6960	}
		6961
		6962	DEBUG_PRINT1 (":\n");
		6963	PUSH_FAILURE_POINT (p + mcnt, d, -2);
		6964	break;
		6965
		6966
		6967	/* A smart repeat ends with `maybe_pop_jump'.
		6968	We change it to either `pop_failure_jump' or `jump'. */
		6969	case maybe_pop_jump:
		6970	EXTRACT_NUMBER_AND_INCR (mcnt, p);
		6971	DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);
		6972	{
		6973	register UCHAR_T *p2 = p;
		6974
		6975	/* Compare the beginning of the repeat with what in the
		6976	pattern follows its end. If we can establish that there
		6977	is nothing that they would both match, i.e., that we
		6978	would have to backtrack because of (as in, e.g., `a*a')
		6979	then we can change to pop_failure_jump, because we'll
		6980	never have to backtrack.
		6981
		6982	This is not true in the case of alternatives: in
		6983	`(a\|ab)*' we do need to backtrack to the `ab' alternative
		6984	(e.g., if the string was `ab'). But instead of trying to
		6985	detect that here, the alternative has put on a dummy
		6986	failure point which is what we will end up popping. */
		6987
		6988	/* Skip over open/close-group commands.
		6989	If what follows this loop is a ...+ construct,
		6990	look at what begins its body, since we will have to
		6991	match at least one of that. */
		6992	while (1)
		6993	{
		6994	if (p2 + 2 < pend
		6995	&& ((re_opcode_t) *p2 == stop_memory
		6996	\|\| (re_opcode_t) *p2 == start_memory))
		6997	p2 += 3;
		6998	else if (p2 + 2 + 2 * OFFSET_ADDRESS_SIZE < pend
		6999	&& (re_opcode_t) *p2 == dummy_failure_jump)
		7000	p2 += 2 + 2 * OFFSET_ADDRESS_SIZE;
		7001	else
		7002	break;
		7003	}
		7004
		7005	p1 = p + mcnt;
		7006	/* p1[0] ... p1[2] are the `on_failure_jump' corresponding
		7007	to the `maybe_finalize_jump' of this case. Examine what
		7008	follows. */
		7009
		7010	/* If we're at the end of the pattern, we can change. */
		7011	if (p2 == pend)
		7012	{
		7013	/* Consider what happens when matching ":$.*$"
		7014	against ":/". I don't really understand this code
		7015	yet. */
		7016	p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
		7017	pop_failure_jump;
		7018	DEBUG_PRINT1
		7019	(" End of pattern: change to `pop_failure_jump'.\n");
		7020	}
		7021
		7022	else if ((re_opcode_t) *p2 == exactn
		7023	#ifdef MBS_SUPPORT
		7024	\|\| (re_opcode_t) *p2 == exactn_bin
		7025	#endif
		7026	\|\| (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
		7027	{
		7028	register UCHAR_T c
		7029	= *p2 == (UCHAR_T) endline ? '\n' : p2[2];
		7030
		7031	if (((re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn
		7032	#ifdef MBS_SUPPORT
		7033	\|\| (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn_bin
		7034	#endif
		7035	) && p1[3+OFFSET_ADDRESS_SIZE] != c)
		7036	{
		7037	p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
		7038	pop_failure_jump;
		7039	#ifdef WCHAR
		7040	DEBUG_PRINT3 (" %C != %C => pop_failure_jump.\n",
		7041	(wint_t) c,
		7042	(wint_t) p1[3+OFFSET_ADDRESS_SIZE]);
		7043	#else
		7044	DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n",
		7045	(char) c,
		7046	(char) p1[3+OFFSET_ADDRESS_SIZE]);
		7047	#endif
		7048	}
		7049
		7050	#ifndef WCHAR
		7051	else if ((re_opcode_t) p1[3] == charset
		7052	\|\| (re_opcode_t) p1[3] == charset_not)
		7053	{
		7054	int negate = (re_opcode_t) p1[3] == charset_not;
		7055
		7056	if (c < (unsigned) (p1[4] * BYTEWIDTH)
		7057	&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
		7058	negate = !negate;
		7059
		7060	/* `negate' is equal to 1 if c would match, which means
		7061	that we can't change to pop_failure_jump. */
		7062	if (!negate)
		7063	{
		7064	p[-3] = (unsigned char) pop_failure_jump;
		7065	DEBUG_PRINT1 (" No match => pop_failure_jump.\n");
		7066	}
		7067	}
		7068	#endif /* not WCHAR */
		7069	}
		7070	#ifndef WCHAR
		7071	else if ((re_opcode_t) *p2 == charset)
		7072	{
		7073	/* We win if the first character of the loop is not part
		7074	of the charset. */
		7075	if ((re_opcode_t) p1[3] == exactn
		7076	&& ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
		7077	&& (p2[2 + p1[5] / BYTEWIDTH]
		7078	& (1 << (p1[5] % BYTEWIDTH)))))
		7079	{
		7080	p[-3] = (unsigned char) pop_failure_jump;
		7081	DEBUG_PRINT1 (" No match => pop_failure_jump.\n");
		7082	}
		7083
		7084	else if ((re_opcode_t) p1[3] == charset_not)
		7085	{
		7086	int idx;
		7087	/* We win if the charset_not inside the loop
		7088	lists every character listed in the charset after. */
		7089	for (idx = 0; idx < (int) p2[1]; idx++)
		7090	if (! (p2[2 + idx] == 0
		7091	\|\| (idx < (int) p1[4]
		7092	&& ((p2[2 + idx] & ~ p1[5 + idx]) == 0))))
		7093	break;
		7094
		7095	if (idx == p2[1])
		7096	{
		7097	p[-3] = (unsigned char) pop_failure_jump;
		7098	DEBUG_PRINT1 (" No match => pop_failure_jump.\n");
		7099	}
		7100	}
		7101	else if ((re_opcode_t) p1[3] == charset)
		7102	{
		7103	int idx;
		7104	/* We win if the charset inside the loop
		7105	has no overlap with the one after the loop. */
		7106	for (idx = 0;
		7107	idx < (int) p2[1] && idx < (int) p1[4];
		7108	idx++)
		7109	if ((p2[2 + idx] & p1[5 + idx]) != 0)
		7110	break;
		7111
		7112	if (idx == p2[1] \|\| idx == p1[4])
		7113	{
		7114	p[-3] = (unsigned char) pop_failure_jump;
		7115	DEBUG_PRINT1 (" No match => pop_failure_jump.\n");
		7116	}
		7117	}
		7118	}
		7119	#endif /* not WCHAR */
		7120	}
		7121	p -= OFFSET_ADDRESS_SIZE; /* Point at relative address again. */
		7122	if ((re_opcode_t) p[-1] != pop_failure_jump)
		7123	{
		7124	p[-1] = (UCHAR_T) jump;
		7125	DEBUG_PRINT1 (" Match => jump.\n");
		7126	goto unconditional_jump;
		7127	}
		7128	/* Note fall through. */
		7129
		7130
		7131	/* The end of a simple repeat has a pop_failure_jump back to
		7132	its matching on_failure_jump, where the latter will push a
		7133	failure point. The pop_failure_jump takes off failure
		7134	points put on by this pop_failure_jump's matching
		7135	on_failure_jump; we got through the pattern to here from the
		7136	matching on_failure_jump, so didn't fail. */
		7137	case pop_failure_jump:
		7138	{
		7139	/* We need to pass separate storage for the lowest and
		7140	highest registers, even though we don't care about the
		7141	actual values. Otherwise, we will restore only one
		7142	register from the stack, since lowest will == highest in
		7143	`pop_failure_point'. */
		7144	active_reg_t dummy_low_reg, dummy_high_reg;
		7145	UCHAR_T *pdummy ATTRIBUTE_UNUSED = NULL;
		7146	const CHAR_T *sdummy ATTRIBUTE_UNUSED = NULL;
		7147
		7148	DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
		7149	POP_FAILURE_POINT (sdummy, pdummy,
		7150	dummy_low_reg, dummy_high_reg,
		7151	reg_dummy, reg_dummy, reg_info_dummy);
		7152	}
		7153	/* Note fall through. */
		7154
		7155	unconditional_jump:
		7156	#ifdef _LIBC
		7157	DEBUG_PRINT2 ("\n%p: ", p);
		7158	#else
		7159	DEBUG_PRINT2 ("\n0x%x: ", p);
		7160	#endif
		7161	/* Note fall through. */
		7162
		7163	/* Unconditionally jump (without popping any failure points). */
		7164	case jump:
		7165	EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */
		7166	DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
		7167	p += mcnt; /* Do the jump. */
		7168	#ifdef _LIBC
		7169	DEBUG_PRINT2 ("(to %p).\n", p);
		7170	#else
		7171	DEBUG_PRINT2 ("(to 0x%x).\n", p);
		7172	#endif
		7173	break;
		7174
		7175
		7176	/* We need this opcode so we can detect where alternatives end
		7177	in `group_match_null_string_p' et al. */
		7178	case jump_past_alt:
		7179	DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");
		7180	goto unconditional_jump;
		7181
		7182
		7183	/* Normally, the on_failure_jump pushes a failure point, which
		7184	then gets popped at pop_failure_jump. We will end up at
		7185	pop_failure_jump, also, and with a pattern of, say, `a+', we
		7186	are skipping over the on_failure_jump, so we have to push
		7187	something meaningless for pop_failure_jump to pop. */
		7188	case dummy_failure_jump:
		7189	DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");
		7190	/* It doesn't matter what we push for the string here. What
		7191	the code at `fail' tests is the value for the pattern. */
		7192	PUSH_FAILURE_POINT (NULL, NULL, -2);
		7193	goto unconditional_jump;
		7194
		7195
		7196	/* At the end of an alternative, we need to push a dummy failure
		7197	point in case we are followed by a `pop_failure_jump', because
		7198	we don't want the failure point for the alternative to be
		7199	popped. For example, matching `(a\|ab)*' against `aab'
		7200	requires that we match the `ab' alternative. */
		7201	case push_dummy_failure:
		7202	DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");
		7203	/* See comments just above at `dummy_failure_jump' about the
		7204	two zeroes. */
		7205	PUSH_FAILURE_POINT (NULL, NULL, -2);
		7206	break;
		7207
		7208	/* Have to succeed matching what follows at least n times.
		7209	After that, handle like `on_failure_jump'. */
		7210	case succeed_n:
		7211	EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
		7212	DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);
		7213
		7214	assert (mcnt >= 0);
		7215	/* Originally, this is how many times we HAVE to succeed. */
		7216	if (mcnt > 0)
		7217	{
		7218	mcnt--;
		7219	p += OFFSET_ADDRESS_SIZE;
		7220	STORE_NUMBER_AND_INCR (p, mcnt);
		7221	#ifdef _LIBC
		7222	DEBUG_PRINT3 (" Setting %p to %d.\n", p - OFFSET_ADDRESS_SIZE
		7223	, mcnt);
		7224	#else
		7225	DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p - OFFSET_ADDRESS_SIZE
		7226	, mcnt);
		7227	#endif
		7228	}
		7229	else if (mcnt == 0)
		7230	{
		7231	#ifdef _LIBC
		7232	DEBUG_PRINT2 (" Setting two bytes from %p to no_op.\n",
		7233	p + OFFSET_ADDRESS_SIZE);
		7234	#else
		7235	DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n",
		7236	p + OFFSET_ADDRESS_SIZE);
		7237	#endif /* _LIBC */
		7238
		7239	#ifdef WCHAR
		7240	p[1] = (UCHAR_T) no_op;
		7241	#else
		7242	p[2] = (UCHAR_T) no_op;
		7243	p[3] = (UCHAR_T) no_op;
		7244	#endif /* WCHAR */
		7245	goto on_failure;
		7246	}
		7247	break;
		7248
		7249	case jump_n:
		7250	EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
		7251	DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
		7252
		7253	/* Originally, this is how many times we CAN jump. */
		7254	if (mcnt)
		7255	{
		7256	mcnt--;
		7257	STORE_NUMBER (p + OFFSET_ADDRESS_SIZE, mcnt);
		7258
		7259	#ifdef _LIBC
		7260	DEBUG_PRINT3 (" Setting %p to %d.\n", p + OFFSET_ADDRESS_SIZE,
		7261	mcnt);
		7262	#else
		7263	DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p + OFFSET_ADDRESS_SIZE,
		7264	mcnt);
		7265	#endif /* _LIBC */
		7266	goto unconditional_jump;
		7267	}
		7268	/* If don't have to jump any more, skip over the rest of command. */
		7269	else
		7270	p += 2 * OFFSET_ADDRESS_SIZE;
		7271	break;
		7272
		7273	case set_number_at:
		7274	{
		7275	DEBUG_PRINT1 ("EXECUTING set_number_at.\n");
		7276
		7277	EXTRACT_NUMBER_AND_INCR (mcnt, p);
		7278	p1 = p + mcnt;
		7279	EXTRACT_NUMBER_AND_INCR (mcnt, p);
		7280	#ifdef _LIBC
		7281	DEBUG_PRINT3 (" Setting %p to %d.\n", p1, mcnt);
		7282	#else
		7283	DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt);
		7284	#endif
		7285	STORE_NUMBER (p1, mcnt);
		7286	break;
		7287	}
		7288
		7289	#if 0
		7290	/* The DEC Alpha C compiler 3.x generates incorrect code for the
		7291	test WORDCHAR_P (d - 1) != WORDCHAR_P (d) in the expansion of
		7292	AT_WORD_BOUNDARY, so this code is disabled. Expanding the
		7293	macro and introducing temporary variables works around the bug. */
		7294
		7295	case wordbound:
		7296	DEBUG_PRINT1 ("EXECUTING wordbound.\n");
		7297	if (AT_WORD_BOUNDARY (d))
		7298	break;
		7299	goto fail;
		7300
		7301	case notwordbound:
		7302	DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
		7303	if (AT_WORD_BOUNDARY (d))
		7304	goto fail;
		7305	break;
		7306	#else
		7307	case wordbound:
		7308	{
		7309	boolean prevchar, thischar;
		7310
		7311	DEBUG_PRINT1 ("EXECUTING wordbound.\n");
		7312	if (AT_STRINGS_BEG (d) \|\| AT_STRINGS_END (d))
		7313	break;
		7314
		7315	prevchar = WORDCHAR_P (d - 1);
		7316	thischar = WORDCHAR_P (d);
		7317	if (prevchar != thischar)
		7318	break;
		7319	goto fail;
		7320	}
		7321
		7322	case notwordbound:
		7323	{
		7324	boolean prevchar, thischar;
		7325
		7326	DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
		7327	if (AT_STRINGS_BEG (d) \|\| AT_STRINGS_END (d))
		7328	goto fail;
		7329
		7330	prevchar = WORDCHAR_P (d - 1);
		7331	thischar = WORDCHAR_P (d);
		7332	if (prevchar != thischar)
		7333	goto fail;
		7334	break;
		7335	}
		7336	#endif
		7337
		7338	case wordbeg:
		7339	DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
		7340	if (!AT_STRINGS_END (d) && WORDCHAR_P (d)
		7341	&& (AT_STRINGS_BEG (d) \|\| !WORDCHAR_P (d - 1)))
		7342	break;
		7343	goto fail;
		7344
		7345	case wordend:
		7346	DEBUG_PRINT1 ("EXECUTING wordend.\n");
		7347	if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)
		7348	&& (AT_STRINGS_END (d) \|\| !WORDCHAR_P (d)))
		7349	break;
		7350	goto fail;
		7351
		7352	#ifdef emacs
		7353	case before_dot:
		7354	DEBUG_PRINT1 ("EXECUTING before_dot.\n");
		7355	if (PTR_CHAR_POS ((unsigned char *) d) >= point)
		7356	goto fail;
		7357	break;
		7358
		7359	case at_dot:
		7360	DEBUG_PRINT1 ("EXECUTING at_dot.\n");
		7361	if (PTR_CHAR_POS ((unsigned char *) d) != point)
		7362	goto fail;
		7363	break;
		7364
		7365	case after_dot:
		7366	DEBUG_PRINT1 ("EXECUTING after_dot.\n");
		7367	if (PTR_CHAR_POS ((unsigned char *) d) <= point)
		7368	goto fail;
		7369	break;
		7370
		7371	case syntaxspec:
		7372	DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);
		7373	mcnt = *p++;
		7374	goto matchsyntax;
		7375
		7376	case wordchar:
		7377	DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");
		7378	mcnt = (int) Sword;
		7379	matchsyntax:
		7380	PREFETCH ();
		7381	/* Can't use d++ here; SYNTAX may be an unsafe macro. /
		7382	d++;
		7383	if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt)
		7384	goto fail;
		7385	SET_REGS_MATCHED ();
		7386	break;
		7387
		7388	case notsyntaxspec:
		7389	DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);
		7390	mcnt = *p++;
		7391	goto matchnotsyntax;
		7392
		7393	case notwordchar:
		7394	DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");
		7395	mcnt = (int) Sword;
		7396	matchnotsyntax:
		7397	PREFETCH ();
		7398	/* Can't use d++ here; SYNTAX may be an unsafe macro. /
		7399	d++;
		7400	if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt)
		7401	goto fail;
		7402	SET_REGS_MATCHED ();
		7403	break;
		7404
		7405	#else /* not emacs */
		7406	case wordchar:
		7407	DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");
		7408	PREFETCH ();
		7409	if (!WORDCHAR_P (d))
		7410	goto fail;
		7411	SET_REGS_MATCHED ();
		7412	d++;
		7413	break;
		7414
		7415	case notwordchar:
		7416	DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");
		7417	PREFETCH ();
		7418	if (WORDCHAR_P (d))
		7419	goto fail;
		7420	SET_REGS_MATCHED ();
		7421	d++;
		7422	break;
		7423	#endif /* not emacs */
		7424
		7425	default:
		7426	abort ();
		7427	}
		7428	continue; /* Successfully executed one pattern command; keep going. */
		7429
		7430
		7431	/* We goto here if a matching operation fails. */
		7432	fail:
		7433	if (!FAIL_STACK_EMPTY ())
		7434	{ /* A restart point is known. Restore to that state. */
		7435	DEBUG_PRINT1 ("\nFAIL:\n");
		7436	POP_FAILURE_POINT (d, p,
		7437	lowest_active_reg, highest_active_reg,
		7438	regstart, regend, reg_info);
		7439
		7440	/* If this failure point is a dummy, try the next one. */
		7441	if (!p)
		7442	goto fail;
		7443
		7444	/* If we failed to the end of the pattern, don't examine p. /
		7445	assert (p <= pend);
		7446	if (p < pend)
		7447	{
		7448	boolean is_a_jump_n = false;
		7449
		7450	/* If failed to a backwards jump that's part of a repetition
		7451	loop, need to pop this failure point and use the next one. */
		7452	switch ((re_opcode_t) *p)
		7453	{
		7454	case jump_n:
		7455	is_a_jump_n = true;
		7456	case maybe_pop_jump:
		7457	case pop_failure_jump:
		7458	case jump:
		7459	p1 = p + 1;
		7460	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7461	p1 += mcnt;
		7462
		7463	if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
		7464	\|\| (!is_a_jump_n
		7465	&& (re_opcode_t) *p1 == on_failure_jump))
		7466	goto fail;
		7467	break;
		7468	default:
		7469	/* do nothing */ ;
		7470	}
		7471	}
		7472
		7473	if (d >= string1 && d <= end1)
		7474	dend = end_match_1;
		7475	}
		7476	else
		7477	break; /* Matching at this starting point really fails. */
		7478	} /* for (;;) */
		7479
		7480	if (best_regs_set)
		7481	goto restore_best_regs;
		7482
		7483	FREE_VARIABLES ();
		7484
		7485	return -1; /* Failure to match. */
		7486	} /* re_match_2 */
		7487
		7488	/* Subroutine definitions for re_match_2. */
		7489
		7490
		7491	/* We are passed P pointing to a register number after a start_memory.
		7492
		7493	Return true if the pattern up to the corresponding stop_memory can
		7494	match the empty string, and false otherwise.
		7495
		7496	If we find the matching stop_memory, sets P to point to one past its number.
		7497	Otherwise, sets P to an undefined byte less than or equal to END.
		7498
		7499	We don't handle duplicates properly (yet). */
		7500
		7501	static boolean
		7502	PREFIX(group_match_null_string_p) (UCHAR_T *p, UCHAR_T end,
		7503	PREFIX(register_info_type) *reg_info)
		7504	{
		7505	int mcnt;
		7506	/* Point to after the args to the start_memory. */
		7507	UCHAR_T p1 = p + 2;
		7508
		7509	while (p1 < end)
		7510	{
		7511	/* Skip over opcodes that can match nothing, and return true or
		7512	false, as appropriate, when we get to one that can't, or to the
		7513	matching stop_memory. */
		7514
		7515	switch ((re_opcode_t) *p1)
		7516	{
		7517	/* Could be either a loop or a series of alternatives. */
		7518	case on_failure_jump:
		7519	p1++;
		7520	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7521
		7522	/* If the next operation is not a jump backwards in the
		7523	pattern. */
		7524
		7525	if (mcnt >= 0)
		7526	{
		7527	/* Go through the on_failure_jumps of the alternatives,
		7528	seeing if any of the alternatives cannot match nothing.
		7529	The last alternative starts with only a jump,
		7530	whereas the rest start with on_failure_jump and end
		7531	with a jump, e.g., here is the pattern for `a\|b\|c':
		7532
		7533	/on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
		7534	/on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
		7535	/exactn/1/c
		7536
		7537	So, we have to first go through the first (n-1)
		7538	alternatives and then deal with the last one separately. */
		7539
		7540
		7541	/* Deal with the first (n-1) alternatives, which start
		7542	with an on_failure_jump (see above) that jumps to right
		7543	past a jump_past_alt. */
		7544
		7545	while ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] ==
		7546	jump_past_alt)
		7547	{
		7548	/* `mcnt' holds how many bytes long the alternative
		7549	is, including the ending `jump_past_alt' and
		7550	its number. */
		7551
		7552	if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt -
		7553	(1 + OFFSET_ADDRESS_SIZE),
		7554	reg_info))
		7555	return false;
		7556
		7557	/* Move to right after this alternative, including the
		7558	jump_past_alt. */
		7559	p1 += mcnt;
		7560
		7561	/* Break if it's the beginning of an n-th alternative
		7562	that doesn't begin with an on_failure_jump. */
		7563	if ((re_opcode_t) *p1 != on_failure_jump)
		7564	break;
		7565
		7566	/* Still have to check that it's not an n-th
		7567	alternative that starts with an on_failure_jump. */
		7568	p1++;
		7569	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7570	if ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] !=
		7571	jump_past_alt)
		7572	{
		7573	/* Get to the beginning of the n-th alternative. */
		7574	p1 -= 1 + OFFSET_ADDRESS_SIZE;
		7575	break;
		7576	}
		7577	}
		7578
		7579	/* Deal with the last alternative: go back and get number
		7580	of the `jump_past_alt' just before it. `mcnt' contains
		7581	the length of the alternative. */
		7582	EXTRACT_NUMBER (mcnt, p1 - OFFSET_ADDRESS_SIZE);
		7583
		7584	if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt, reg_info))
		7585	return false;
		7586
		7587	p1 += mcnt; /* Get past the n-th alternative. */
		7588	} /* if mcnt > 0 */
		7589	break;
		7590
		7591
		7592	case stop_memory:
		7593	assert (p1[1] == **p);
		7594	*p = p1 + 2;
		7595	return true;
		7596
		7597
		7598	default:
		7599	if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
		7600	return false;
		7601	}
		7602	} /* while p1 < end */
		7603
		7604	return false;
		7605	} /* group_match_null_string_p */
		7606
		7607
		7608	/* Similar to group_match_null_string_p, but doesn't deal with alternatives:
		7609	It expects P to be the first byte of a single alternative and END one
		7610	byte past the last. The alternative can contain groups. */
		7611
		7612	static boolean
		7613	PREFIX(alt_match_null_string_p) (UCHAR_T p, UCHAR_T end,
		7614	PREFIX(register_info_type) *reg_info)
		7615	{
		7616	int mcnt;
		7617	UCHAR_T *p1 = p;
		7618
		7619	while (p1 < end)
		7620	{
		7621	/* Skip over opcodes that can match nothing, and break when we get
		7622	to one that can't. */
		7623
		7624	switch ((re_opcode_t) *p1)
		7625	{
		7626	/* It's a loop. */
		7627	case on_failure_jump:
		7628	p1++;
		7629	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7630	p1 += mcnt;
		7631	break;
		7632
		7633	default:
		7634	if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
		7635	return false;
		7636	}
		7637	} /* while p1 < end */
		7638
		7639	return true;
		7640	} /* alt_match_null_string_p */
		7641
		7642
		7643	/* Deals with the ops common to group_match_null_string_p and
		7644	alt_match_null_string_p.
		7645
		7646	Sets P to one after the op and its arguments, if any. */
		7647
		7648	static boolean
		7649	PREFIX(common_op_match_null_string_p) (UCHAR_T *p, UCHAR_T end,
		7650	PREFIX(register_info_type) *reg_info)
		7651	{
		7652	int mcnt;
		7653	boolean ret;
		7654	int reg_no;
		7655	UCHAR_T p1 = p;
		7656
		7657	switch ((re_opcode_t) *p1++)
		7658	{
		7659	case no_op:
		7660	case begline:
		7661	case endline:
		7662	case begbuf:
		7663	case endbuf:
		7664	case wordbeg:
		7665	case wordend:
		7666	case wordbound:
		7667	case notwordbound:
		7668	#ifdef emacs
		7669	case before_dot:
		7670	case at_dot:
		7671	case after_dot:
		7672	#endif
		7673	break;
		7674
		7675	case start_memory:
		7676	reg_no = *p1;
		7677	assert (reg_no > 0 && reg_no <= MAX_REGNUM);
		7678	ret = PREFIX(group_match_null_string_p) (&p1, end, reg_info);
		7679
		7680	/* Have to set this here in case we're checking a group which
		7681	contains a group and a back reference to it. */
		7682
		7683	if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE)
		7684	REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret;
		7685
		7686	if (!ret)
		7687	return false;
		7688	break;
		7689
		7690	/* If this is an optimized succeed_n for zero times, make the jump. */
		7691	case jump:
		7692	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7693	if (mcnt >= 0)
		7694	p1 += mcnt;
		7695	else
		7696	return false;
		7697	break;
		7698
		7699	case succeed_n:
		7700	/* Get to the number of times to succeed. */
		7701	p1 += OFFSET_ADDRESS_SIZE;
		7702	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7703
		7704	if (mcnt == 0)
		7705	{
		7706	p1 -= 2 * OFFSET_ADDRESS_SIZE;
		7707	EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		7708	p1 += mcnt;
		7709	}
		7710	else
		7711	return false;
		7712	break;
		7713
		7714	case duplicate:
		7715	if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))
		7716	return false;
		7717	break;
		7718
		7719	case set_number_at:
		7720	p1 += 2 * OFFSET_ADDRESS_SIZE;
		7721
		7722	default:
		7723	/* All other opcodes mean we cannot match the empty string. */
		7724	return false;
		7725	}
		7726
		7727	*p = p1;
		7728	return true;
		7729	} /* common_op_match_null_string_p */
		7730
		7731
		7732	/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
		7733	bytes; nonzero otherwise. */
		7734
		7735	static int
		7736	PREFIX(bcmp_translate) (const CHAR_T s1, const CHAR_T s2, register int len,
		7737	RE_TRANSLATE_TYPE translate)
		7738	{
		7739	register const UCHAR_T p1 = (const UCHAR_T ) s1;
		7740	register const UCHAR_T p2 = (const UCHAR_T ) s2;
		7741	while (len)
		7742	{
		7743	#ifdef WCHAR
		7744	if (((p1<=0xff)?translate[p1++]:*p1++)
		7745	!= ((p2<=0xff)?translate[p2++]:*p2++))
		7746	return 1;
		7747	#else /* BYTE */
		7748	if (translate[p1++] != translate[p2++]) return 1;
		7749	#endif /* WCHAR */
		7750	len--;
		7751	}
		7752	return 0;
		7753	}
		7754
		7755
		7756	#else /* not INSIDE_RECURSION */
		7757
		7758	/* Entry points for GNU code. */
		7759
		7760	/* re_compile_pattern is the GNU regular expression compiler: it
		7761	compiles PATTERN (of length SIZE) and puts the result in BUFP.
		7762	Returns 0 if the pattern was valid, otherwise an error string.
		7763
		7764	Assumes the `allocated' (and perhaps `buffer') and `translate' fields
		7765	are set in BUFP on entry.
		7766
		7767	We call regex_compile to do the actual compilation. */
		7768
		7769	const char *
		7770	re_compile_pattern (const char *pattern, size_t length,
		7771	struct re_pattern_buffer *bufp)
		7772	{
		7773	reg_errcode_t ret;
		7774
		7775	/* GNU code is written to assume at least RE_NREGS registers will be set
		7776	(and at least one extra will be -1). */
		7777	bufp->regs_allocated = REGS_UNALLOCATED;
		7778
		7779	/* And GNU code determines whether or not to get register information
		7780	by passing null for the REGS argument to re_match, etc., not by
		7781	setting no_sub. */
		7782	bufp->no_sub = 0;
		7783
		7784	/* Match anchors at newline. */
		7785	bufp->newline_anchor = 1;
		7786
		7787	# ifdef MBS_SUPPORT
		7788	if (MB_CUR_MAX != 1)
		7789	ret = wcs_regex_compile (pattern, length, re_syntax_options, bufp);
		7790	else
		7791	# endif
		7792	ret = byte_regex_compile (pattern, length, re_syntax_options, bufp);
		7793
		7794	if (!ret)
		7795	return NULL;
		7796	return gettext (re_error_msgid[(int) ret]);
		7797	}
		7798	#ifdef _LIBC
		7799	weak_alias (__re_compile_pattern, re_compile_pattern)
		7800	#endif
		7801
		7802	/* Entry points compatible with 4.2 BSD regex library. We don't define
		7803	them unless specifically requested. */
		7804
		7805	#if defined _REGEX_RE_COMP \|\| defined _LIBC
		7806
		7807	/* BSD has one and only one pattern buffer. */
		7808	static struct re_pattern_buffer re_comp_buf;
		7809
		7810	char *
		7811	#ifdef _LIBC
		7812	/* Make these definitions weak in libc, so POSIX programs can redefine
		7813	these names if they don't use our functions, and still use
		7814	regcomp/regexec below without link errors. */
		7815	weak_function
		7816	#endif
		7817	re_comp (const char *s)
		7818	{
		7819	reg_errcode_t ret;
		7820
		7821	if (!s)
		7822	{
		7823	if (!re_comp_buf.buffer)
		7824	return (char *) gettext ("No previous regular expression");
		7825	return 0;
		7826	}
		7827
		7828	if (!re_comp_buf.buffer)
		7829	{
		7830	re_comp_buf.buffer = (unsigned char *) malloc (200);
		7831	if (re_comp_buf.buffer == NULL)
		7832	return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
		7833	re_comp_buf.allocated = 200;
		7834
		7835	re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
		7836	if (re_comp_buf.fastmap == NULL)
		7837	return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
		7838	}
		7839
		7840	/* Since `re_exec' always passes NULL for the `regs' argument, we
		7841	don't need to initialize the pattern buffer fields which affect it. */
		7842
		7843	/* Match anchors at newlines. */
		7844	re_comp_buf.newline_anchor = 1;
		7845
		7846	# ifdef MBS_SUPPORT
		7847	if (MB_CUR_MAX != 1)
		7848	ret = wcs_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
		7849	else
		7850	# endif
		7851	ret = byte_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
		7852
		7853	if (!ret)
		7854	return NULL;
		7855
		7856	/* Yes, we're discarding `const' here if !HAVE_LIBINTL. */
		7857	return (char *) gettext (re_error_msgid[(int) ret]);
		7858	}
		7859
		7860
		7861	int
		7862	#ifdef _LIBC
		7863	weak_function
		7864	#endif
		7865	re_exec (const char *s)
		7866	{
		7867	const int len = strlen (s);
		7868	return
		7869
		7870	}
		7871
		7872	#endif /* _REGEX_RE_COMP */
		7873
		7874	/* POSIX.2 functions. Don't define these for Emacs. */
		7875
		7876	#ifndef emacs
		7877
		7878	/* regcomp takes a regular expression as a string and compiles it.
		7879
		7880	PREG is a regex_t *. We do not expect any fields to be initialized,
		7881	since POSIX says we shouldn't. Thus, we set
		7882
		7883	`buffer' to the compiled pattern;
		7884	`used' to the length of the compiled pattern;
		7885	`syntax' to RE_SYNTAX_POSIX_EXTENDED if the
		7886	REG_EXTENDED bit in CFLAGS is set; otherwise, to
		7887	RE_SYNTAX_POSIX_BASIC;
		7888	`newline_anchor' to REG_NEWLINE being set in CFLAGS;
		7889	`fastmap' to an allocated space for the fastmap;
		7890	`fastmap_accurate' to zero;
		7891	`re_nsub' to the number of subexpressions in PATTERN.
		7892
		7893	PATTERN is the address of the pattern string.
		7894
		7895	CFLAGS is a series of bits which affect compilation.
		7896
		7897	If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
		7898	use POSIX basic syntax.
		7899
		7900	If REG_NEWLINE is set, then . and [^...] don't match newline.
		7901	Also, regexec will try a match beginning after every newline.
		7902
		7903	If REG_ICASE is set, then we considers upper- and lowercase
		7904	versions of letters to be equivalent when matching.
		7905
		7906	If REG_NOSUB is set, then when PREG is passed to regexec, that
		7907	routine will report only success or failure, and nothing about the
		7908	registers.
		7909
		7910	It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for
		7911	the return codes and their meanings.) */
		7912
		7913	int
		7914	regcomp (regex_t preg, const char pattern, int cflags)
		7915	{
		7916	reg_errcode_t ret;
		7917	reg_syntax_t syntax
		7918	= (cflags & REG_EXTENDED) ?
		7919	RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
		7920
		7921	/* regex_compile will allocate the space for the compiled pattern. */
		7922	preg->buffer = 0;
		7923	preg->allocated = 0;
		7924	preg->used = 0;
		7925
		7926	/* Try to allocate space for the fastmap. */
		7927	preg->fastmap = (char *) malloc (1 << BYTEWIDTH);
		7928
		7929	if (cflags & REG_ICASE)
		7930	{
		7931	int i;
		7932
		7933	preg->translate
		7934	= (RE_TRANSLATE_TYPE) malloc (CHAR_SET_SIZE
		7935	* sizeof (*(RE_TRANSLATE_TYPE)0));
		7936	if (preg->translate == NULL)
		7937	return (int) REG_ESPACE;
		7938
		7939	/* Map uppercase characters to corresponding lowercase ones. */
		7940	for (i = 0; i < CHAR_SET_SIZE; i++)
		7941	preg->translate[i] = ISUPPER (i) ? TOLOWER (i) : i;
		7942	}
		7943	else
		7944	preg->translate = NULL;
		7945
		7946	/* If REG_NEWLINE is set, newlines are treated differently. */
		7947	if (cflags & REG_NEWLINE)
		7948	{ /* REG_NEWLINE implies neither . nor [^...] match newline. */
		7949	syntax &= ~RE_DOT_NEWLINE;
		7950	syntax \|= RE_HAT_LISTS_NOT_NEWLINE;
		7951	/* It also changes the matching behavior. */
		7952	preg->newline_anchor = 1;
		7953	}
		7954	else
		7955	preg->newline_anchor = 0;
		7956
		7957	preg->no_sub = !!(cflags & REG_NOSUB);
		7958
		7959	/* POSIX says a null character in the pattern terminates it, so we
		7960	can use strlen here in compiling the pattern. */
		7961	# ifdef MBS_SUPPORT
		7962	if (MB_CUR_MAX != 1)
		7963	ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg);
		7964	else
		7965	# endif
		7966	ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg);
		7967
		7968	/* POSIX doesn't distinguish between an unmatched open-group and an
		7969	unmatched close-group: both are REG_EPAREN. */
		7970	if (ret == REG_ERPAREN) ret = REG_EPAREN;
		7971
		7972	if (ret == REG_NOERROR && preg->fastmap)
		7973	{
		7974	/* Compute the fastmap now, since regexec cannot modify the pattern
		7975	buffer. */
		7976	if (re_compile_fastmap (preg) == -2)
		7977	{
		7978	/* Some error occurred while computing the fastmap, just forget
		7979	about it. */
		7980	free (preg->fastmap);
		7981	preg->fastmap = NULL;
		7982	}
		7983	}
		7984
		7985	return (int) ret;
		7986	}
		7987	#ifdef _LIBC
		7988	weak_alias (__regcomp, regcomp)
		7989	#endif
		7990
		7991
		7992	/* regexec searches for a given pattern, specified by PREG, in the
		7993	string STRING.
		7994
		7995	If NMATCH is zero or REG_NOSUB was set in the cflags argument to
		7996	`regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at
		7997	least NMATCH elements, and we set them to the offsets of the
		7998	corresponding matched substrings.
		7999
		8000	EFLAGS specifies `execution flags' which affect matching: if
		8001	REG_NOTBOL is set, then ^ does not match at the beginning of the
		8002	string; if REG_NOTEOL is set, then $ does not match at the end.
		8003
		8004	We return 0 if we find a match and REG_NOMATCH if not. */
		8005
		8006	int
		8007	regexec (const regex_t preg, const char string, size_t nmatch,
		8008	regmatch_t pmatch[], int eflags)
		8009	{
		8010	int ret;
		8011	struct re_registers regs;
		8012	regex_t private_preg;
		8013	int len = strlen (string);
		8014	boolean want_reg_info = !preg->no_sub && nmatch > 0;
		8015
		8016	private_preg = *preg;
		8017
		8018	private_preg.not_bol = !!(eflags & REG_NOTBOL);
		8019	private_preg.not_eol = !!(eflags & REG_NOTEOL);
		8020
		8021	/* The user has told us exactly how many registers to return
		8022	information about, via `nmatch'. We have to pass that on to the
		8023	matching routines. */
		8024	private_preg.regs_allocated = REGS_FIXED;
		8025
		8026	if (want_reg_info)
		8027	{
		8028	regs.num_regs = nmatch;
		8029	regs.start = TALLOC (nmatch * 2, regoff_t);
		8030	if (regs.start == NULL)
		8031	return (int) REG_NOMATCH;
		8032	regs.end = regs.start + nmatch;
		8033	}
		8034
		8035	/* Perform the searching operation. */
		8036	ret = re_search (&private_preg, string, len,
		8037	/* start: / 0, / range: */ len,
		8038	want_reg_info ? ®s : (struct re_registers *) 0);
		8039
		8040	/* Copy the register information to the POSIX structure. */
		8041	if (want_reg_info)
		8042	{
		8043	if (ret >= 0)
		8044	{
		8045	unsigned r;
		8046
		8047	for (r = 0; r < nmatch; r++)
		8048	{
		8049	pmatch[r].rm_so = regs.start[r];
		8050	pmatch[r].rm_eo = regs.end[r];
		8051	}
		8052	}
		8053
		8054	/* If we needed the temporary register info, free the space now. */
		8055	free (regs.start);
		8056	}
		8057
		8058	/* We want zero return to mean success, unlike `re_search'. */
		8059	return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
		8060	}
		8061	#ifdef _LIBC
		8062	weak_alias (__regexec, regexec)
		8063	#endif
		8064
		8065
		8066	/* Returns a message corresponding to an error code, ERRCODE, returned
		8067	from either regcomp or regexec. We don't use PREG here. */
		8068
		8069	size_t
		8070	regerror (int errcode, const regex_t *preg ATTRIBUTE_UNUSED,
		8071	char *errbuf, size_t errbuf_size)
		8072	{
		8073	const char *msg;
		8074	size_t msg_size;
		8075
		8076	if (errcode < 0
		8077	\|\| errcode >= (int) (sizeof (re_error_msgid)
		8078	/ sizeof (re_error_msgid[0])))
		8079	/* Only error codes returned by the rest of the code should be passed
		8080	to this routine. If we are given anything else, or if other regex
		8081	code generates an invalid error code, then the program has a bug.
		8082	Dump core so we can fix it. */
		8083	abort ();
		8084
		8085	msg = gettext (re_error_msgid[errcode]);
		8086
		8087	msg_size = strlen (msg) + 1; /* Includes the null. */
		8088
		8089	if (errbuf_size != 0)
		8090	{
		8091	if (msg_size > errbuf_size)
		8092	{
		8093	#if defined HAVE_MEMPCPY \|\| defined _LIBC
		8094	((char ) mempcpy (errbuf, msg, errbuf_size - 1)) = '\0';
		8095	#else
6324	serge	8096	(void) memcpy (errbuf, msg, errbuf_size - 1);
5191	serge	8097	errbuf[errbuf_size - 1] = 0;
		8098	#endif
		8099	}
		8100	else
6324	serge	8101	(void) memcpy (errbuf, msg, msg_size);
5191	serge	8102	}
		8103
		8104	return msg_size;
		8105	}
		8106	#ifdef _LIBC
		8107	weak_alias (__regerror, regerror)
		8108	#endif
		8109
		8110
		8111	/* Free dynamically allocated space used by PREG. */
		8112
		8113	void
		8114	regfree (regex_t *preg)
		8115	{
		8116	free (preg->buffer);
		8117	preg->buffer = NULL;
		8118
		8119	preg->allocated = 0;
		8120	preg->used = 0;
		8121
		8122	free (preg->fastmap);
		8123	preg->fastmap = NULL;
		8124	preg->fastmap_accurate = 0;
		8125
		8126	free (preg->translate);
		8127	preg->translate = NULL;
		8128	}
		8129	#ifdef _LIBC
		8130	weak_alias (__regfree, regfree)
		8131	#endif
		8132
		8133	#endif /* not emacs */
		8134
		8135	#endif /* not INSIDE_RECURSION */
		8136
		8137
		8138	#undef STORE_NUMBER
		8139	#undef STORE_NUMBER_AND_INCR
		8140	#undef EXTRACT_NUMBER
		8141	#undef EXTRACT_NUMBER_AND_INCR
		8142
		8143	#undef DEBUG_PRINT_COMPILED_PATTERN
		8144	#undef DEBUG_PRINT_DOUBLE_STRING
		8145
		8146	#undef INIT_FAIL_STACK
		8147	#undef RESET_FAIL_STACK
		8148	#undef DOUBLE_FAIL_STACK
		8149	#undef PUSH_PATTERN_OP
		8150	#undef PUSH_FAILURE_POINTER
		8151	#undef PUSH_FAILURE_INT
		8152	#undef PUSH_FAILURE_ELT
		8153	#undef POP_FAILURE_POINTER
		8154	#undef POP_FAILURE_INT
		8155	#undef POP_FAILURE_ELT
		8156	#undef DEBUG_PUSH
		8157	#undef DEBUG_POP
		8158	#undef PUSH_FAILURE_POINT
		8159	#undef POP_FAILURE_POINT
		8160
		8161	#undef REG_UNSET_VALUE
		8162	#undef REG_UNSET
		8163
		8164	#undef PATFETCH
		8165	#undef PATFETCH_RAW
		8166	#undef PATUNFETCH
		8167	#undef TRANSLATE
		8168
		8169	#undef INIT_BUF_SIZE
		8170	#undef GET_BUFFER_SPACE
		8171	#undef BUF_PUSH
		8172	#undef BUF_PUSH_2
		8173	#undef BUF_PUSH_3
		8174	#undef STORE_JUMP
		8175	#undef STORE_JUMP2
		8176	#undef INSERT_JUMP
		8177	#undef INSERT_JUMP2
		8178	#undef EXTEND_BUFFER
		8179	#undef GET_UNSIGNED_NUMBER
		8180	#undef FREE_STACK_RETURN
		8181
		8182	# undef POINTER_TO_OFFSET
		8183	# undef MATCHING_IN_FRST_STRING
		8184	# undef PREFETCH
		8185	# undef AT_STRINGS_BEG
		8186	# undef AT_STRINGS_END
		8187	# undef WORDCHAR_P
		8188	# undef FREE_VAR
		8189	# undef FREE_VARIABLES
		8190	# undef NO_HIGHEST_ACTIVE_REG
		8191	# undef NO_LOWEST_ACTIVE_REG
		8192
		8193	# undef CHAR_T
		8194	# undef UCHAR_T
		8195	# undef COMPILED_BUFFER_VAR
		8196	# undef OFFSET_ADDRESS_SIZE
		8197	# undef CHAR_CLASS_SIZE
		8198	# undef PREFIX
		8199	# undef ARG_PREFIX
		8200	# undef PUT_CHAR
		8201	# undef BYTE
		8202	# undef WCHAR
		8203
		8204	# define DEFINED_ONCE

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/libiberty/regex.c – Rev 8031