modif struct svnwindows@3001

1 files changed, 0 insertions, 1758 deletions

diff --git a/Bus/Ivy/Regexp.cxx b/Bus/Ivy/Regexp.cxx
deleted file mode 100644
index 4dc1823..0000000
--- a/Bus/Ivy/Regexp.cxx
+++ /dev/null
@@ -1,1758 +0,0 @@
-// Win32 porting notes.

-

-#if defined( _MBCS )

-#pragma message( __FILE__ "This code is broken under _MBCS, " \

-				 "see the comments at the top of this file." )

-#endif //_MBCS

-//

-//

-// In case this isn't obvious from the later comments this is an ALTERED

-// version of the software. If you like my changes then cool, but nearly

-// all of the functionality here is derived from Henry Spencer's original

-// work.

-//

-// This code should work correctly under both _SBCS and _UNICODE, I did

-// start working on making it work with _MBCS but gave up after a while

-// since I don't need this particular port and it's not going to be as

-// straight forward as the other two.

-//

-// The problem stems from the compiled program being stored as TCHARS,

-// the individual items need to be wide enough to hold whatever character

-// is thrown at them, but currently they are accessed as an array of

-// whatever size integral type is appropriate.  _MBCS would cause this

-// to be char, but at times it would need to be larger.  This would

-// require making the program be an array of short with the appropriate

-// conversions used everywhere.  Certainly it's doable, but it's a pain.

-// What's worse is that the current code will compile and run under _MBCS,

-// only breaking when it gets wide characters thrown against it.

-//

-// I've marked at least one bit of code with #pragma messages, I may not

-// get all of them, but they should be a start

-//

-// Guy Gascoigne - Piggford (ggp@bigfoot.com) Friday, February 27, 1998

-

-

-// regcomp and regexec -- regsub and regerror are elsewhere

-// @(#)regexp.c	1.3 of 18 April 87

-//

-//	Copyright (c) 1986 by University of Toronto.

-//	Written by Henry Spencer.  Not derived from licensed software.

-//

-//	Permission is granted to anyone to use this software for any

-//	purpose on any computer system, and to redistribute it freely,

-//	subject to the following restrictions:

-//

-//	1. The author is not responsible for the consequences of use of

-//		this software, no matter how awful, even if they arise

-//		from defects in it.

-//

-//	2. The origin of this software must not be misrepresented, either

-//		by explicit claim or by omission.

-//

-//	3. Altered versions must be plainly marked as such, and must not

-//		be misrepresented as being the original software.

-// *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,

-// *** hoptoad!gnu, on 27 Dec 1986, to add \< and \> for word-matching

-// *** as in BSD grep and ex.

-// *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,

-// *** hoptoad!gnu, on 28 Dec 1986, to optimize characters quoted with \.

-// *** THIS IS AN ALTERED VERSION.  It was altered by James A. Woods,

-// *** ames!jaw, on 19 June 1987, to quash a regcomp() redundancy.

-// *** THIS IS AN ALTERED VERSION.  It was altered by Geoffrey Noer,

-// *** THIS IS AN ALTERED VERSION.  It was altered by Guy Gascoigne - Piggford

-// *** guy@wyrdrune.com, on 15 March 1998, porting it to C++ and converting

-// *** it to be the engine for the Regexp class

-//

-// Beware that some of this code is subtly aware of the way operator

-// precedence is structured in regular expressions.  Serious changes in

-// regular-expression syntax might require a total rethink.

-

-#include "IvyStdAfx.h"

-#include "regexp.h"

-

-// The first byte of the regexp internal "program" is actually this magic

-// number; the start node begins in the second byte.

-

-const char	MAGIC = '\234';

-

-#pragma warning( disable : 4711 )	// automatic inline selected

-

-// The "internal use only" fields in regexp.h are present to pass info from

-// compile to execute that permits the execute phase to run lots faster on

-// simple cases.  They are:

-//

-// regstart	char that must begin a match; '\0' if none obvious

-// reganch	is the match anchored (at beginning-of-line only)?

-// regmust	string (pointer into program) that match must include, or NULL

-// regmlen	length of regmust string

-//

-// Regstart and reganch permit very fast decisions on suitable starting

-// points for a match, cutting down the work a lot.  Regmust permits fast

-// rejection of lines that cannot possibly match.  The regmust tests are

-// costly enough that regcomp() supplies a regmust only if the

-// r.e. contains something potentially expensive (at present, the only

-// such thing detected is * or + at the start of the r.e., which can

-// involve a lot of backup).  Regmlen is supplied because the test in

-// regexec() needs it and regcomp() is computing it anyway.

-

-// Structure for regexp "program".  This is essentially a linear encoding

-// of a nondeterministic finite-state machine (aka syntax charts or

-// "railroad normal form" in parsing technology).  Each node is an opcode

-// plus a "next" pointer, possibly plus an operand.  "Next" pointers of

-// all nodes except BRANCH implement concatenation; a "next" pointer with

-// a BRANCH on both ends of it is connecting two alternatives.  (Here we

-// have one of the subtle syntax dependencies: an individual BRANCH (as

-// opposed to a collection of them) is never concatenated with anything

-// because of operator precedence.)  The operand of some types of node is

-// a literal string; for others, it is a node leading into a sub-FSM.  In

-// particular, the operand of a BRANCH node is the first node of the

-// branch.  (NB this is *not* a tree structure: the tail of the branch

-// connects to the thing following the set of BRANCHes.)  The opcodes

-// are:

-

-enum {

-//  definition	number		opnd?	meaning

-	END		=	0,		//	no		End of program.

-	BOL		=	1,		//	no		Match beginning of line.

-	EOL		=	2,		//	no		Match end of line.

-	ANY		=	3,		//	no		Match any character.

-	ANYOF	=	4,		//	str		Match any of these.

-	ANYBUT	=	5,		//	str		Match any but one of these.

-	BRANCH	=	6,		//	node	Match this, or the next..\&.

-	BACK	=	7,		//	no		"next" ptr points backward.

-	EXACTLY	=	8,		//	str		Match this string.

-	NOTHING	=	9,		//	no		Match empty string.

-	STAR	=	10,		//	node	Match this 0 or more times.

-	PLUS	=	11,		//	node	Match this 1 or more times.

-	WORDA	=	12,		//	no		Match "" at wordchar, where prev is nonword

-	WORDZ	=	13,		//	no		Match "" at nonwordchar, where prev is word

-	OPEN	=	20,		//	no		Sub-RE starts here.

-						//			OPEN+1 is number 1, etc.

-	CLOSE	=	40		//	no		Analogous to OPEN.

-};

-

-// Opcode notes:

-//

-// BRANCH	The set of branches constituting a single choice are hooked

-//		together with their "next" pointers, since precedence prevents

-//		anything being concatenated to any individual branch.  The

-//		"next" pointer of the last BRANCH in a choice points to the

-//		thing following the whole choice.  This is also where the

-//		final "next" pointer of each individual branch points; each

-//		branch starts with the operand node of a BRANCH node.

-//

-// BACK		Normal "next" pointers all implicitly point forward; BACK

-//		exists to make loop structures possible.

-//

-// STAR,PLUS	'?', and complex '*' and '+', are implemented as circular

-//		BRANCH structures using BACK.  Simple cases (one character

-//		per match) are implemented with STAR and PLUS for speed

-//		and to minimize recursive plunges.

-//

-// OPEN,CLOSE	...are numbered at compile time.

-

-// A node is one char of opcode followed by two chars of "next" pointer.

-// "Next" pointers are stored as two 8-bit pieces, high order first.  The

-// value is a positive offset from the opcode of the node containing it.

-// An operand, if any, simply follows the node.  (Note that much of the

-// code generation knows about this implicit relationship.)

-//

-// Using two bytes for the "next" pointer is vast overkill for most things,

-// but allows patterns to get big without disasters.

-

-

-enum

-{

-	REGERR_SENTINEL_VALUE = 0,

-	REGERR_NULLARG = 1, REGERR_CORRUPTED, REGERR_CORRUPTION, REGERR_CORRUPTED_POINTERS,

-	REGERR_BAD_REGREPEAT, REGERR_CORRUPTED_OPCODE, REGERR_NULL_TO_REGSUB,

-	REGERR_DAMAGED_REGEXP_REGSUB, REGERR_DAMAGED_MATCH_STRING, REGERR_NULL_TO_REGCOMP,

-	REGERR_TO_BIG, REGERR_TO_MANY_PAREN, REGERR_UNTERMINATED_PAREN, REGERR_UNMATCHED_PAREN,

-	REGERR_INTERNAL_ERROR_JUNK, REGERR_OP_COULD_BE_EMPTY, REGERR_NESTED_OP, REGERR_INVALID_RANGE,

-	REGERR_UNMATCHED_BRACE, REGERR_INTERNAL_UNEXPECTED_CHAR, REGERR_OP_FOLLOWS_NOTHING,

-	REGERR_TRAILING_ESC, REGERR_INTERNAL_STRSCSPN, REGERR_NO_REGEXP

-};

-

-struct regErr

-{

-	int m_id;

-	const char * m_err;

-} errors[] = {

-	{ REGERR_NULLARG,					"NULL argument to regexec"  },

-	{ REGERR_CORRUPTED,					"corrupted regexp"  },

-	{ REGERR_CORRUPTION,				"regexp corruption"  },

-	{ REGERR_CORRUPTED_POINTERS,		"corrupted pointers"  },

-	{ REGERR_BAD_REGREPEAT,				"internal error: bad call of regrepeat"  },

-	{ REGERR_CORRUPTED_OPCODE,			"corrupted opcode"  },

-	{ REGERR_NULL_TO_REGSUB,			"NULL parm to regsub"  },

-	{ REGERR_DAMAGED_REGEXP_REGSUB,		"damaged regexp fed to regsub"  },

-	{ REGERR_DAMAGED_MATCH_STRING,		"damaged match string"  },

-	{ REGERR_NULL_TO_REGCOMP,			"NULL argument to regcomp"  },

-	{ REGERR_TO_BIG,					"regexp too big"  },

-	{ REGERR_TO_MANY_PAREN,				"too many ()"  },

-	{ REGERR_UNTERMINATED_PAREN,		"unterminated ()"  },

-	{ REGERR_UNMATCHED_PAREN,			"unmatched ()" },

-	{ REGERR_INTERNAL_ERROR_JUNK,		"internal error: junk on end"  },

-	{ REGERR_OP_COULD_BE_EMPTY,			"*+ operand could be empty"  },

-	{ REGERR_NESTED_OP,					"nested *?+"  },

-	{ REGERR_INVALID_RANGE,				"invalid [] range"  },

-	{ REGERR_UNMATCHED_BRACE,			"unmatched []"  },

-	{ REGERR_INTERNAL_UNEXPECTED_CHAR,	"internal error: \\0|) unexpected"  },

-	{ REGERR_OP_FOLLOWS_NOTHING,		"?+* follows nothing"  },

-	{ REGERR_TRAILING_ESC,				"trailing \\"  },

-	{ REGERR_INTERNAL_STRSCSPN,			"internal error: strcspn 0"  },

-	{ REGERR_NO_REGEXP,					"NULL regexp"  },

-	{ REGERR_SENTINEL_VALUE,			"Unknown error" }							// must be last value

-};

-

-// Flags to be passed up and down.

-

-enum {

-	HASWIDTH	=	01,	// Known never to match null string.

-	SIMPLE		=	02,	// Simple enough to be STAR/PLUS operand.

-	SPSTART		=	04,	// Starts with * or +.

-	WORST		=	0	// Worst case.

-};

-

-///////////////////////////////////////////////////////////////////////////////

-

-class CRegErrorHandler

-{

-	friend Regexp;

-	mutable ivy::string m_szError;

-	static const char * FindErr( int id );

-protected:

-	void ClearErrorString() const;

-	void regerror( const char * s ) const;

-	void regerror( int id ) const;

-public:

-	CRegErrorHandler() { }

-	CRegErrorHandler( const CRegErrorHandler & reh ) : m_szError( reh.m_szError ) {}

-

-	const ivy::string & GetErrorString() const;

-};

-

-void CRegErrorHandler::regerror( const char * s ) const

-{

-	TRACE( "regerror: %s\n", s );

-	m_szError = s;

-}

-

-void CRegErrorHandler::regerror( int id ) const

-{

-	regerror( FindErr( id ) );

-}

-

-const ivy::string & CRegErrorHandler::GetErrorString() const

-{

-	return m_szError;

-}

-

-void CRegErrorHandler::ClearErrorString() const

-{

-	m_szError.erase() ;

-}

-

-const char * CRegErrorHandler::FindErr( int id )

-{

-	struct regErr * perr;

-	for ( perr = errors; perr->m_id != REGERR_SENTINEL_VALUE; perr++ )

-		if ( perr->m_id == id )

-			return perr->m_err;

-

-	return perr->m_err;		// since we've fallen off the array, perr->m_id == 0

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-// All of the functions required to directly access the 'program'

-class CRegProgramAccessor : public CRegErrorHandler

-{

-public:

-	static inline char OP( char * p )

-	{

-		return (*(p));

-	}

-	static inline char * OPERAND( char * p )

-	{

-		return p + 3;

-	}

-	static inline char * regnext( char * p )

-	{

-		const short offset = *((short*)(p+1));

-

-		if (offset == 0)

-			return(NULL);

-		

-		return((OP(p) == BACK) ? p-offset : p+offset);

-	}

-#ifdef _RE_DEBUG

-	char * CRegProgramAccessor::regprop( char * op );

-#endif

-};

-

-///////////////////////////////////////////////////////////////////////////////

-

-// The internal interface to the regexp, wrapping the compilation as well as the

-// execution of the regexp (matching)

-

-class regexp : public CRegProgramAccessor

-{

-	friend class CRegExecutor;

-	friend class Regexp;

-	

-	int m_programSize;

-	char * startp[Regexp::NSUBEXP];

-	char * endp[Regexp::NSUBEXP];

-	char regstart;		// Internal use only.

-	char reganch;		// Internal use only.

-	char * regmust;		// Internal use only.

-	int regmlen;		// Internal use only.

-	char * program;

-	

-	bool status;

-	int count;			// used by Regexp to manage the reference counting of regexps

-	int numSubs;

-public:

-	

-	regexp( const char * exp, bool iCase );

-	regexp( const regexp & r );

-	~regexp();

-	

-	void ignoreCase( const char * in, char * out );

-	

-	bool regcomp( const char * exp );

-	bool regexec( const char * string );

-	bool Status() const { return status; }

-

-	ivy::string GetReplaceString( const char* sReplaceExp ) const;

-

-	regexp * getCopy();

-

-#ifdef _RE_DEBUG

-	void  regdump();

-#endif

-	

-#ifdef _DEBUG

-	ivy::string m_originalPattern;

-	ivy::string m_modifiedPattern;

-#endif

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// Compile / Validate the regular expression - ADT

-

-class CRegCompilerBase : public CRegProgramAccessor

-{

-public:

-	CRegCompilerBase( const char * parse );

-

-	char * reg(int paren, int *flagp);

-protected:

-	char * regparse;	// Input-scan pointer. 

-	int regnpar;		// () count. 

-

-	char * regbranch(int *flagp);

-	char * regpiece(int *flagp);

-	char * regatom(int *flagp);

-	inline bool ISREPN( char c )	{ return ((c) == '*' || (c) == '+' || (c) == '?'); }

-

-	virtual void regc(int c) = 0;

-	virtual char * regnode(int op) = 0;

-	virtual void reginsert(char op, char * opnd) = 0;

-	virtual void regtail(char * p, char * val) = 0;

-	virtual void regoptail(char * p, char * val) = 0;

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// First pass over the expression, testing for validity and returning the 

-// program size

-

-class CRegValidator : public CRegCompilerBase

-{

-public:

-	CRegValidator( const char * parse );

-

-	inline long Size() const { return regsize; }

-private:

-	long regsize;		// Code size. 

-	char regdummy[3];	// NOTHING, 0 next ptr 

-protected:

-	char * regnode(int) { regsize += 3; return regdummy; }

-	void regc(int) { regsize++; }

-	void reginsert(char, char *) { regsize += 3; }

-	void regtail(char *, char *) { return; }

-	void regoptail(char *, char *) { return; }

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// Second pass, actually generating the program

-

-class CRegCompiler : public CRegCompilerBase

-{

-public:

-	CRegCompiler( const char * parse, char * prog );

-private:

-	char * regcode;

-protected:

-	// regc - emit (if appropriate) a byte of code

-	void regc(int b)

-	{

-		*regcode++ = (char)b;

-	}

-	char * regnode(int op);

-	void reginsert(char op, char * opnd);

-	void regtail(char * p, char * val);

-	void regoptail(char * p, char * val);

-};

-

-// regnode - emit a node

-char * CRegCompiler::regnode(int op)

-{

-	char * const ret = regcode;

-

-	char * ptr = ret;

-	*ptr++ = (char)op;

-	*ptr++ = '\0';		// Null next pointer. 

-	*ptr++ = '\0';

-	regcode = ptr;

-

-	return(ret);

-}

-

-// reginsert - insert an operator in front of already-emitted operand

-//

-// Means relocating the operand.

-void CRegCompiler::reginsert(char op, char * opnd)

-{

-	char * place;

-

-	(void) memmove(opnd+3, opnd, (size_t)((regcode - opnd)*sizeof(char)));

-	regcode += 3;

-

-	place = opnd;		// Op node, where operand used to be.

-	*place++ = op;

-	*place++ = '\0';

-	*place++ = '\0';

-}

-

-// regtail - set the next-pointer at the end of a node chain

-void CRegCompiler::regtail(char * p, char * val)

-{

-	char * scan;

-	char * temp;

-

-	// Find last node. 

-	for (scan = p; (temp = regnext(scan)) != NULL; scan = temp)

-		continue;

-

-	*((short *)(scan+1)) = (short)((OP(scan) == BACK) ? scan - val : val - scan);

-}

-

-// regoptail - regtail on operand of first argument; nop if operandless

-void CRegCompiler::regoptail(char * p, char * val)

-{

-	// "Operandless" and "op != BRANCH" are synonymous in practice. 

-	if (OP(p) == BRANCH)

-		regtail(OPERAND(p), val);

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-CRegCompilerBase::CRegCompilerBase( const char * parse )

-	: regparse( (char *)parse ),

-	regnpar(1)

-{

-}

-

-CRegValidator::CRegValidator( const char * parse )

-	: CRegCompilerBase( parse ),

-	regsize(0)

-{

-	regc(MAGIC);

-	regdummy[0] = NOTHING;

-	regdummy[1] = regdummy[2] = 0;

-}

-

-CRegCompiler::CRegCompiler( const char * parse, char * prog )

-	: CRegCompilerBase( parse ),

-	regcode(prog)

-{

-	regc(MAGIC);

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-regexp::regexp( const char * exp, bool iCase )

-	: regstart(0),

-	reganch(0),

-	regmust(0),

-	regmlen(0),

-	program(0),

-	m_programSize(0)

-{

-#if _DEBUG

-	m_originalPattern = exp;		// keep a version of the pattern for debugging

-#endif

-

-	if ( iCase )

-	{

-		char * out = new char[(strlen( exp ) * 4) + 1];

-		ignoreCase( exp, out );

-

-#if _DEBUG

-		m_modifiedPattern = out;	// and the modified version if there is one

-#endif

-		status = regcomp( out );

-		delete [] out;

-	}

-	else

-		status = regcomp( exp );

-

-	count = numSubs = 0;

-}

-

-regexp::regexp( const regexp & orig )

-	: regstart(orig.regstart),

-	reganch(orig.reganch),

-	regmlen(orig.regmlen),

-	m_programSize(orig.m_programSize),

-	numSubs(orig.numSubs),

-	regmust(0)

-{

-#if _DEBUG

-	m_originalPattern = orig.m_originalPattern;

-	m_modifiedPattern = orig.m_modifiedPattern;

-#endif

-	status = orig.status;

-	count = 0;

-	program = new char[m_programSize];

-	memcpy( program, orig.program, m_programSize * sizeof( char ) );

-	if ( orig.regmust )

-		regmust = program + ( orig.regmust - orig.program );

-

-	for ( int i = Regexp::NSUBEXP - 1; i >= 0; i--)

-	{

-		startp[i] = orig.startp[i];

-		endp[i] = orig.endp[i];

-	}

-}

-

-regexp::~regexp()

-{

-	delete [] program;

-}

-

-

-// regcomp - compile a regular expression into internal code

-//

-// We can't allocate space until we know how big the compiled form will

-// be, but we can't compile it (and thus know how big it is) until we've

-// got a place to put the code.  So we cheat: we compile it twice, once

-// with code generation turned off and size counting turned on, and once

-// "for real".  This also means that we don't allocate space until we are

-// sure that the thing really will compile successfully, and we never

-// have to move the code and thus invalidate pointers into it.  (Note

-// that it has to be in one piece because free() must be able to free it

-// all.)

-//

-// Beware that the optimization-preparation code in here knows about some

-// of the structure of the compiled regexp.

-

-bool regexp::regcomp(const char * exp)

-{

-	char * scan;

-	int flags;

-

-	if (exp == NULL)

-	{

-		regerror( REGERR_NULL_TO_REGCOMP );

-		return NULL;

-	}

-

-	// First pass: determine size, legality.

-	CRegValidator tester( exp );

-

-	if (tester.reg(0, &flags) == NULL)

-		return false;

-

-	// Small enough for pointer-storage convention? 

-	if (tester.Size() >= 0x7fffL)	// Probably could be 0xffffL. 

-	{

-		regerror(REGERR_TO_BIG);

-		return NULL;

-	}

-

-	m_programSize = tester.Size();

-	// Allocate space. 

-	program = new char[m_programSize];

-

-	CRegCompiler comp( exp, program );

-	// Second pass: emit code. 

-	if (comp.reg(0, &flags) == NULL)

-		return false;

-

-	scan = program + 1;			// First BRANCH. 

-	if (OP(regnext(scan)) == END)

-	{		// Only one top-level choice. 

-		scan = OPERAND(scan);

-

-		// Starting-point info. 

-		if (OP(scan) == EXACTLY)

-			regstart = *OPERAND(scan);

-		else if (OP(scan) == BOL)

-			reganch = 1;

-

-		// If there's something expensive in the r.e., find the

-		// longest literal string that must appear and make it the

-		// regmust.  Resolve ties in favor of later strings, since

-		// the regstart check works with the beginning of the r.e.

-		// and avoiding duplication strengthens checking.  Not a

-		// strong reason, but sufficient in the absence of others.

-		 

-		if (flags&SPSTART) 

-		{

-			char * longest = NULL;

-			size_t len = 0;

-

-			for (; scan != NULL; scan = regnext(scan))

-				if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len)

-				{

-					longest = OPERAND(scan);

-					len = strlen(OPERAND(scan));

-				}

-			regmust = longest;

-			regmlen = (int)len;

-		}

-	}

-

-	return true;

-}

-

-regexp * regexp::getCopy()

-{

-	return new regexp( *this );

-}

-

-// reg - regular expression, i.e. main body or parenthesized thing

-//

-// Caller must absorb opening parenthesis.

-//

-// Combining parenthesis handling with the base level of regular expression

-// is a trifle forced, but the need to tie the tails of the branches to what

-// follows makes it hard to avoid.

-

-char * CRegCompilerBase::reg( int paren, int *flagp )

-{

-	char * ret = NULL;

-	char * br;

-	char * ender;

-	int parno = 0;

-	int flags;

-

-	*flagp = HASWIDTH;	// Tentatively. 

-

-	if (paren)

-	{

-		// Make an OPEN node. 

-		if (regnpar >= Regexp::NSUBEXP)

-		{

-			regerror(REGERR_TO_MANY_PAREN);

-			return NULL;

-		}

-		parno = regnpar;

-		regnpar++;

-		ret = regnode(OPEN+parno);

-	}

-

-	// Pick up the branches, linking them together. 

-	br = regbranch(&flags);

-	if (br == NULL)

-		return(NULL);

-	if (paren)

-		regtail(ret, br);	// OPEN -> first. 

-	else

-		ret = br;

-	*flagp &= ~(~flags&HASWIDTH);	// Clear bit if bit 0. 

-	*flagp |= flags&SPSTART;

-	while (*regparse == '|')

-	{

-		regparse++;

-		br = regbranch(&flags);

-		if (br == NULL)

-			return(NULL);

-		regtail(ret, br);	// BRANCH -> BRANCH. 

-		*flagp &= ~(~flags&HASWIDTH);

-		*flagp |= flags&SPSTART;

-	}

-

-	// Make a closing node, and hook it on the end. 

-	ender = regnode((paren) ? CLOSE+parno : END);

-	regtail(ret, ender);

-

-	// Hook the tails of the branches to the closing node. 

-	for (br = ret; br != NULL; br = regnext(br))

-		regoptail(br, ender);

-

-	// Check for proper termination. 

-	if (paren && *regparse++ != ')')

-	{

-		regerror( REGERR_UNTERMINATED_PAREN );

-		return NULL;

-	}

-	else if (!paren && *regparse != '\0')

-	{

-		if (*regparse == ')')

-		{

-			regerror( REGERR_UNMATCHED_PAREN );

-			return NULL;

-		}

-		else

-		{

-			regerror( REGERR_INTERNAL_ERROR_JUNK );

-			return NULL;

-		}

-		// NOTREACHED 

-	}

-

-	return(ret);

-}

-

-// regbranch - one alternative of an | operator

-//

-// Implements the concatenation operator.

-

-char * CRegCompilerBase::regbranch(int *flagp)

-{

-	char * ret;

-	char * chain;

-	char * latest;

-	int flags;

-	int c;

-

-	*flagp = WORST;				// Tentatively. 

-

-	ret = regnode(BRANCH);

-	chain = NULL;

-	while ((c = *regparse) != '\0' && c != '|' && c != ')')

-	{

-		latest = regpiece(&flags);

-		if (latest == NULL)

-			return(NULL);

-		*flagp |= flags&HASWIDTH;

-		if (chain == NULL)		// First piece. 

-			*flagp |= flags&SPSTART;

-		else

-			regtail(chain, latest);

-		chain = latest;

-	}

-	if (chain == NULL)			// Loop ran zero times. 

-		(void) regnode(NOTHING);

-

-	return(ret);

-}

-

-// regpiece - something followed by possible [*+?]

-//

-// Note that the branching code sequences used for ? and the general cases

-// of * and + are somewhat optimized:  they use the same NOTHING node as

-// both the endmarker for their branch list and the body of the last branch.

-// It might seem that this node could be dispensed with entirely, but the

-// endmarker role is not redundant.

-

-char * CRegCompilerBase::regpiece(int *flagp)

-{

-	char * ret;

-	char op;

-	char * next;

-	int flags;

-

-	ret = regatom(&flags);

-	if (ret == NULL)

-		return(NULL);

-

-	op = *regparse;

-	if (!ISREPN(op))

-	{

-		*flagp = flags;

-		return(ret);

-	}

-

-	if (!(flags&HASWIDTH) && op != '?' )

-	{

-		regerror( REGERR_OP_COULD_BE_EMPTY );

-		return NULL;

-	}

-	switch (op)

-	{

-		case '*' :	*flagp = WORST|SPSTART;				break;

-		case '+' :	*flagp = WORST|SPSTART|HASWIDTH;	break;

-		case '?' :	*flagp = WORST;						break;

-	}

-

-	if (op == '*'  && (flags&SIMPLE))

-		reginsert(STAR, ret);

-	else if (op == '*' )

-	{

-		// Emit x* as (x&|), where & means "self". 

-		reginsert(BRANCH, ret);				// Either x 

-		regoptail(ret, regnode(BACK));		// and loop 

-		regoptail(ret, ret);				// back 

-		regtail(ret, regnode(BRANCH));		// or 

-		regtail(ret, regnode(NOTHING));		// null. 

-	}

-	else if (op == '+'  && (flags&SIMPLE))

-		reginsert(PLUS, ret);

-	else if (op == '+' )

-	{

-		// Emit x+ as x(&|), where & means "self". 

-		next = regnode(BRANCH);				// Either 

-		regtail(ret, next);

-		regtail(regnode(BACK), ret);		// loop back 

-		regtail(next, regnode(BRANCH));		// or 

-		regtail(ret, regnode(NOTHING));		// null. 

-	}

-	else if (op == '?' )

-	{

-		// Emit x? as (x|) 

-		reginsert(BRANCH, ret);				// Either x 

-		regtail(ret, regnode(BRANCH));		// or 

-		next = regnode(NOTHING);			// null. 

-		regtail(ret, next);

-		regoptail(ret, next);

-	}

-	regparse++;

-	if (ISREPN(*regparse))

-	{

-		regerror( REGERR_NESTED_OP );

-		return NULL;

-	}

-

-	return(ret);

-}

-

-// regatom - the lowest level

-//

-// Optimization:  gobbles an entire sequence of ordinary characters so that

-// it can turn them into a single node, which is smaller to store and

-// faster to run.  Backslashed characters are exceptions, each becoming a

-// separate node; the code is simpler that way and it's not worth fixing.

-

-char * CRegCompilerBase::regatom(int * flagp)

-{

-	char * ret;

-	int flags;

-

-	*flagp = WORST;		// Tentatively. 

-

-	switch ( *regparse++ )

-	{

-		// FIXME: these chars only have meaning at beg/end of pat?

-		case '^':

-			ret = regnode(BOL);

-			break;

-		case '$':

-			ret = regnode(EOL);

-			break;

-		case '.':

-			ret = regnode(ANY);

-			*flagp |= HASWIDTH|SIMPLE;

-			break;

-		case '[':

-		{

-			int range;

-			int rangeend;

-			int c;

-

-			if (*regparse == '^')

-			{	// Complement of range. 

-				ret = regnode(ANYBUT);

-				regparse++;

-			}

-			else

-				ret = regnode(ANYOF);

-			if ((c = *regparse) == ']' || c == '-')

-			{

-				regc(c);

-				regparse++;

-			}

-			while ((c = *regparse++ ) != '\0' && c != ']')

-			{

-				if (c != '-')

-					regc(c);

-				else if ((c = *regparse) == ']' || c == '\0')

-					regc('-');

-				else

-				{

-					range = (char)*(regparse-2);

-					rangeend = (char)c;

-					if (range > rangeend)

-					{

-						regerror( REGERR_INVALID_RANGE );

-						return NULL;

-					}

-					for (range++; range <= rangeend; range++)

-						regc(range);

-					regparse++;

-				}

-			}

-			regc('\0');

-			if (c != ']')

-			{

-				regerror( REGERR_UNMATCHED_BRACE );

-				return NULL;

-			}

-			*flagp |= HASWIDTH|SIMPLE;

-			break;

-		}

-		case '(':

-			ret = reg(1, &flags);

-			if (ret == NULL)

-				return(NULL);

-			*flagp |= flags&(HASWIDTH|SPSTART);

-			break;

-		case '\0':

-		case '|':

-		case ')':

-			// supposed to be caught earlier 

-			regerror( REGERR_INTERNAL_UNEXPECTED_CHAR );

-			return NULL;

-		case '?':

-		case '+':

-		case '*':

-			{

-				regerror( REGERR_OP_FOLLOWS_NOTHING );

-				return NULL;

-			}

-		case '\\':

-			switch (*regparse++)

-			{

-				case '\0':

-				{

-					regerror( REGERR_TRAILING_ESC );

-					return NULL;

-				}

-				case '<':

-					ret = regnode(WORDA);

-					break;

-				case '>':

-					ret = regnode(WORDZ);

-					break;

-				/* FIXME: Someday handle \1, \2, ... */

-				default:

-					/* Handle general quoted chars in exact-match routine */

-					goto de_fault;

-			}

-			break;

-	de_fault:

-	default:

-		// Encode a string of characters to be matched exactly.

-		//

-		// This is a bit tricky due to quoted chars and due to

-		// '*', '+', and '?' taking the SINGLE char previous

-		// as their operand.

-		//

-		// On entry, the char at regparse[-1] is going to go

-		// into the string, no matter what it is.  (It could be

-		// following a \ if we are entered from the '\' case.)

-		// 

-		// Basic idea is to pick up a good char in  ch  and

-		// examine the next char.  If it's *+? then we twiddle.

-		// If it's \ then we frozzle.  If it's other magic char

-		// we push  ch  and terminate the string.  If none of the

-		// above, we push  ch  on the string and go around again.

-		//

-		//  regprev  is used to remember where "the current char"

-		// starts in the string, if due to a *+? we need to back

-		// up and put the current char in a separate, 1-char, string.

-		// When  regprev  is NULL,  ch  is the only char in the

-		// string; this is used in *+? handling, and in setting

-		// flags |= SIMPLE at the end.

-		{

-			char *regprev;

-			register char ch;

-

-			regparse--;			/* Look at cur char */

-			ret = regnode(EXACTLY);

-			for ( regprev = 0 ; ; ) {

-				ch = *regparse++;	/* Get current char */

-				switch (*regparse) {	/* look at next one */

-

-				default:

-					regc(ch);	/* Add cur to string */

-					break;

-

-				case '.': case '[': case '(':

-				case ')': case '|': case '\n':

-				case '$': case '^':

-				case '\0':

-				/* FIXME, $ and ^ should not always be magic */

-				magic:

-					regc(ch);	/* dump cur char */

-					goto done;	/* and we are done */

-

-				case '?': case '+': case '*':

-					if (!regprev) 	/* If just ch in str, */

-						goto magic;	/* use it */

-					/* End mult-char string one early */

-					regparse = regprev; /* Back up parse */

-					goto done;

-

-				case '\\':

-					regc(ch);	/* Cur char OK */

-					switch (regparse[1]){ /* Look after \ */

-					case '\0':

-					case '<':

-					case '>':

-					/* FIXME: Someday handle \1, \2, ... */

-						goto done; /* Not quoted */

-					default:

-						/* Backup point is \, scan							 * point is after it. */

-						regprev = regparse;

-						regparse++; 

-						continue;	/* NOT break; */

-					}

-				}

-				regprev = regparse;	/* Set backup point */

-			}

-		done:

-			regc('\0');

-			*flagp |= HASWIDTH;

-			if (!regprev)		/* One char? */

-				*flagp |= SIMPLE;

-		}

-		break;

-	}

-

-	return(ret);

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// regexec and friends

-

-// Work-variable struct for regexec().

-

-class CRegExecutor : public CRegProgramAccessor

-{

-	friend bool regexp::regexec( const char * str );

-

-	char * reginput;		// string-input pointer. 

-	char * regbol;			// Beginning of input, for ^ check. 

-	char * * regstartp;		// Pointer to startp array. 

-	char * * regendp;		// Ditto for endp.

-

-	regexp * prog;

-public:

-	CRegExecutor( regexp * prog, char * string );

-protected:

-	bool regtry( char * string );

-	bool regmatch( char * prog );

-	size_t regrepeat( char * node );

-};

-

-CRegExecutor::CRegExecutor( regexp * p, char * string )

-	: regbol( string ),

-	regstartp( p->startp ),

-	regendp( p->endp ),

-	prog(p)

-{

-}

-

-#ifdef _RE_DEBUG

-int regnarrate = 0;

-#endif

-

-// regexec - match a regexp against a string

-

-bool regexp::regexec( const char * str )

-{

-	char * string = (char *)str;	// avert const poisoning 

-

-	// Be paranoid. 

-	if ( string == NULL )

-	{

-		regerror( REGERR_NULLARG );

-		return false;

-	}

-

-	// Check validity of program. 

-	if (*program != MAGIC)

-	{

-		regerror( REGERR_CORRUPTED );

-		return false;

-	}

-

-	// If there is a "must appear" string, look for it. 

-	if ( regmust != NULL && strstr( string, regmust ) == NULL )

-		return false;

-

-	CRegExecutor executor( this, string );

-

-	// Simplest case:  anchored match need be tried only once. 

-	if ( reganch )

-		return( executor.regtry( string ) );

-

-	// Messy cases:  unanchored match. 

-	if ( regstart != '\0' )

-	{

-		// We know what char it must start with. 

-		for ( char * s = string; s != NULL; s = strchr( s+1 , regstart ) )

-			if ( executor.regtry( s) )

-				return true;

-		return false;

-	}

-	else

-	{

-		// We don't -- general case. 

-		for ( char * s = string; ! executor.regtry( s ); s++ )

-			if (*s == '\0')

-				return false;

-	}

-	return true;

-}

-

-// regtry - try match at specific point

-bool CRegExecutor::regtry( char * string )

-{

-	int i;

-	char * * stp;

-	char * * enp;

-

-	reginput = string;

-

-	stp = prog->startp;

-	enp = prog->endp;

-	for (i = Regexp::NSUBEXP; i > 0; i--)

-	{

-		*stp++ = NULL;

-		*enp++ = NULL;

-	}

-	if ( regmatch( prog->program + 1 ) )

-	{

-		prog->startp[0] = string;

-		prog->endp[0] = reginput;

-		return true;

-	}

-	else

-		return false;

-}

-

-// regmatch - main matching routine

-//

-// Conceptually the strategy is simple:  check to see whether the current

-// node matches, call self recursively to see whether the rest matches,

-// and then act accordingly.  In practice we make some effort to avoid

-// recursion, in particular by going through "ordinary" nodes (that don't

-// need to know whether the rest of the match failed) by a loop instead of

-// by recursion.

-

-bool CRegExecutor::regmatch( char * prog )

-{

-	char * scan;	// Current node. 

-	char * next;		// Next node. 

-

-#ifdef _RE_DEBUG

-	if (prog != NULL && regnarrate)

-		fprintf(stderr, "%s(\n", regprop(prog));

-#endif

-	for (scan = prog; scan != NULL; scan = next)

-	{

-#ifdef _RE_DEBUG

-		if (regnarrate)

-			fprintf(stderr, "%s...\n", regprop(scan));

-#endif

-		next = regnext(scan);

-

-		switch (OP(scan))

-		{

-			case BOL:

-				if (reginput != regbol)

-					return false;

-				break;

-			case EOL:

-				if (*reginput != '\0')

-					return false;

-				break;

-			case WORDA:

-				/* Must be looking at a letter, digit, or _ */

-				if ((!isalnum(*reginput)) && *reginput != '_')

-					return(0);

-				/* Prev must be BOL or nonword */

-				if (reginput > regbol &&

-					(isalnum(reginput[-1]) || reginput[-1] == '_'))

-					return(0);

-				break;

-			case WORDZ:

-				/* Must be looking at non letter, digit, or _ */

-				if (isalnum(*reginput) || *reginput == '_')

-					return(0);

-				/* We don't care what the previous char was */

-				break;

-			case ANY:

-				if (*reginput == '\0')

-					return false;

-				reginput++;

-				break;

-			case EXACTLY:

-			{

-				size_t len;

-				char * const opnd = OPERAND(scan);

-

-				// Inline the first character, for speed. 

-				if (*opnd != *reginput)

-					return false;

-				len = strlen(opnd);

-				if (len > 1 && strncmp(opnd, reginput, len) != 0)

-					return false;

-				reginput += len;

-

-				break;

-			}

-			case ANYOF:

-				if (*reginput == '\0' ||

-						strchr(OPERAND(scan), *reginput) == NULL)

-					return false;

-				reginput++;

-				break;

-			case ANYBUT:

-				if (*reginput == '\0' ||

-						strchr(OPERAND(scan), *reginput) != NULL)

-					return false;

-				reginput++;

-				break;

-			case NOTHING:

-				break;

-			case BACK:

-				break;

-			case OPEN+1: case OPEN+2: case OPEN+3:

-			case OPEN+4: case OPEN+5: case OPEN+6:

-			case OPEN+7: case OPEN+8: case OPEN+9:

-			case OPEN+10: case OPEN+11: case OPEN+12:

-			case OPEN+13: case OPEN+14: case OPEN+15:

-			case OPEN+16: case OPEN+17: case OPEN+18:

-			case OPEN+19:

-			{

-				const int no = OP(scan) - OPEN;

-				char * const input = reginput;

-

-				if (regmatch(next))

-				{

-					// Don't set startp if some later

-					// invocation of the same parentheses

-					// already has.

-					 

-					if (regstartp[no] == NULL)

-						regstartp[no] = input;

-					return true;

-				}

-				else

-					return false;

-				break;

-			}

-			case CLOSE+1: case CLOSE+2: case CLOSE+3:

-			case CLOSE+4: case CLOSE+5: case CLOSE+6:

-			case CLOSE+7: case CLOSE+8: case CLOSE+9:

-			case CLOSE+10: case CLOSE+11: case CLOSE+12:

-			case CLOSE+13: case CLOSE+14: case CLOSE+15:

-			case CLOSE+16: case CLOSE+17: case CLOSE+18:

-			case CLOSE+19:

-			{

-				const int no = OP(scan) - CLOSE;

-				char * const input = reginput;

-

-				if (regmatch(next))

-				{

-					// Don't set endp if some later

-					// invocation of the same parentheses

-					// already has.

-					 

-					if (regendp[no] == NULL)

-						regendp[no] = input;

-					return true;

-				}

-				else

-					return false;

-				break;

-			}

-			case BRANCH:

-			{

-				char * const save = reginput;

-

-				if (OP(next) != BRANCH)		// No choice. 

-					next = OPERAND(scan);	// Avoid recursion. 

-				else

-				{

-					while (OP(scan) == BRANCH)

-					{

-						if (regmatch(OPERAND(scan)))

-							return true;

-						reginput = save;

-						scan = regnext(scan);

-					}

-					return false;

-					// NOTREACHED 

-				}

-				break;

-			}

-			case STAR: case PLUS:

-			{

-				const char nextch = (OP(next) == EXACTLY) ? *OPERAND(next) : '\0';

-				size_t no;

-				char * const save = reginput;

-				const size_t min = (OP(scan) == STAR) ? 0 : 1;

-

-				for (no = regrepeat(OPERAND(scan)) + 1; no > min; no--)

-				{

-					reginput = save + no - 1;

-					// If it could work, try it. 

-					if (nextch == '\0' || *reginput == nextch)

-						if (regmatch(next))

-							return true;

-				}

-				return false;

-				break;

-			}

-			case END:

-				return true;	// Success! 

-				break;

-			default:

-				regerror( REGERR_CORRUPTION );

-				return false;

-				break;

-		}

-	}

-

-	// We get here only if there's trouble -- normally "case END" is

-	// the terminating point.

-

-	regerror( REGERR_CORRUPTED_POINTERS );

-	return false;

-}

-

-// regrepeat - report how many times something simple would match

-

-size_t CRegExecutor::regrepeat( char * node )

-{

-	size_t count;

-	char * scan;

-	char ch;

-

-	switch (OP(node))

-	{

-		case ANY:

-			return(strlen(reginput));

-			break;

-		case EXACTLY:

-			ch = *OPERAND(node);

-			count = 0;

-			for (scan = reginput; *scan == ch; scan++)

-				count++;

-			return(count);

-			break;

-		case ANYOF:

-			return(strspn(reginput, OPERAND(node)));

-			break;

-		case ANYBUT:

-			return(strcspn(reginput, OPERAND(node)));

-			break;

-		default:		// Oh dear.  Called inappropriately. 

-			regerror( REGERR_BAD_REGREPEAT );

-			return(0);	// Best compromise. 

-			break;

-	}

-	// NOTREACHED 

-}

-

-#ifdef _RE_DEBUG

-

-// regdump - dump a regexp onto stdout in vaguely comprehensible form

-

-void regexp::regdump()

-{

-	char * s;

-	char op = EXACTLY;	// Arbitrary non-END op. 

-	char * next;

-

-	s = program + 1;

-	while (op != END)

-	{	// While that wasn't END last time... 

-		op = OP(s);

-		printf("%2d%s", s-program, regprop(s));	// Where, what. 

-		next = regnext(s);

-		if (next == NULL)		// Next ptr. 

-			printf("(0)" );

-		else 

-			printf("(%d)", (s-program)+(next-s));

-		s += 3;

-		if (op == ANYOF || op == ANYBUT || op == EXACTLY)

-		{

-			// Literal string, where present. 

-			while (*s != '\0')

-			{

-				putchar(*s);

-				s++;

-			}

-			s++;

-		}

-		putchar('\n');

-	}

-

-	// Header fields of interest. 

-	if (regstart != '\0')

-		printf("start `%c' ", regstart);

-	if (reganch)

-		printf("anchored ");

-	if (regmust != NULL)

-		printf("must have \"%s\"" , regmust);

-	printf("\n");

-}

-

-// regprop - printable representation of opcode

-

-#define OUTPUT(s) case s: p = #s; break

-char * CRegProgramAccessor::regprop( char * op )

-{

-	char * p = NULL;

-	static char buf[50];

-

-	(void) strcpy(buf, ":" );

-

-	switch (OP(op))

-	{

-	OUTPUT( BOL );

-	OUTPUT( EOL );

-	OUTPUT( ANY );

-	OUTPUT( ANYOF );

-	OUTPUT( ANYBUT );

-	OUTPUT( BRANCH );

-	OUTPUT( EXACTLY );

-	OUTPUT( NOTHING );

-	OUTPUT( BACK );

-	OUTPUT( END );

-	OUTPUT( STAR );

-	OUTPUT( PLUS );

-	OUTPUT( WORDA );

-	OUTPUT( WORDZ );

-	case OPEN+1: case OPEN+2: case OPEN+3:

-	case OPEN+4: case OPEN+5: case OPEN+6:

-	case OPEN+7: case OPEN+8: case OPEN+9:

-	case OPEN+10: case OPEN+11: case OPEN+12:

-	case OPEN+13: case OPEN+14: case OPEN+15:

-	case OPEN+16: case OPEN+17: case OPEN+18:

-	case OPEN+19:

-		sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);

-		p = NULL;

-		break;

-	case CLOSE+1: case CLOSE+2: case CLOSE+3:

-	case CLOSE+4: case CLOSE+5: case CLOSE+6:

-	case CLOSE+7: case CLOSE+8: case CLOSE+9:

-	case CLOSE+10: case CLOSE+11: case CLOSE+12:

-	case CLOSE+13: case CLOSE+14: case CLOSE+15:

-	case CLOSE+16: case CLOSE+17: case CLOSE+18:

-	case CLOSE+19:

-		sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);

-		p = NULL;

-		break;

-	default:

-		regerror( REGERR_CORRUPTED_OPCODE );

-		break;

-	}

-	if (p != NULL)

-		(void) strcat(buf, p);

-	return(buf);

-}

-#endif

-

-///////////////////////////////////////////////////////////////////////////////

-

-Regexp::Regexp()

-	: rc(0),

-	str(0)

-{

-}

-

-Regexp::Regexp( const char * exp, bool iCase )

-	: rc( new regexp( exp, iCase ) ),

-	str( 0 )

-{

-}

-

-Regexp::Regexp( const Regexp &r )

-	: rc( r.rc ),

-	m_szError(r.m_szError),

-	str(r.str)

-{

-	if ( rc )

-		rc->count++;

-}

-

-const Regexp & Regexp::operator=( const Regexp & r )

-{

-	if ( this != &r )

-	{

-		if ( rc && rc->count-- == 0 )

-			delete rc;

-

-		rc = r.rc;

-		if ( rc )

-			rc->count++;

-

-		str = r.str;

-		m_szError = r.m_szError;

-	}	

-	return *this;

-}

-

-Regexp::~Regexp()

-{

-	if ( rc && rc->count-- == 0 )

-		delete rc;

-}

-

-bool Regexp::Match( const char * s )

-{

-	ClearErrorString();

-	str = s;

-	bool ret = false;

-	if ( rc )

-	{

-		// copy on write !

-

-		if ( rc->count )

-		{

-			rc->count--;

-			rc = rc->getCopy();

-		}

-

-		ret = rc->regexec( s );

-		int i = 0;

-		if ( ret )

-			for ( i = 0; i < Regexp::NSUBEXP && rc->startp[i] ; i++ )

-				;

-		rc->numSubs = i - 1;

-	}

-	else

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	return ret;

-}

-

-ivy::string Regexp::GetReplaceString( const char * source ) const

-{

-	ClearErrorString();

-	if ( rc )

-		return rc->GetReplaceString( source );

-	else

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	return "";

-}

-

-int Regexp::SubStrings() const

-{

-	ClearErrorString();

-	int ret = -1;

-	if ( rc )

-		ret = rc->numSubs;

-	else

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	return ret;

-}

-

-size_t Regexp::SubStart( size_t i ) const

-{

-	ClearErrorString();

-	size_t ret = -1;

-	if ( rc )

-		ret = rc->startp[safeIndex(i)] - str;

-	else

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	return ret;

-}

-

-size_t Regexp::SubLength( size_t i ) const

-{

-	ClearErrorString();

-	size_t ret = -1;

-	if ( rc )

-	{

-		i = safeIndex(i);

-		ret = rc->endp[i] - rc->startp[i];

-	}

-	else

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	return ret;

-}

-

-bool Regexp::CompiledOK() const

-{

-	return rc ? rc->Status() : false;

-}

-

-#ifdef _RE_DEBUG

-void Regexp::Dump()

-{

-	if ( rc )

-		rc->regdump();

-#if defined( _DEBUG )

-	else

-		TRACE( "No regexp to dump out\n" );

-#endif

-}

-#endif

-

-size_t Regexp::safeIndex( size_t i ) const

-{

-	return i < Regexp::NSUBEXP ? i : Regexp::NSUBEXP;

-}

-

-const ivy::string Regexp::operator[]( size_t i ) const

-{

-	ivy::string value;

-	ClearErrorString();

-	ASSERT( rc );

-	if ( rc )

-	{

-		size_t len = SubLength(i);

-		//char * szbuf = buffer.GetBufferSetLength( len );

-		//memcpy( szbuf, rc->startp[i], len * sizeof(char) );

-		//buffer.ReleaseBuffer();

-		value =  ivy::string ( rc->startp[i], len );

-	}

-	else

-	{

-		m_szError = CRegErrorHandler::FindErr( REGERR_NO_REGEXP );

-	}

-	return value;

-}

-

-void regexp::ignoreCase( const char * in, char * out )

-{

-	// copy in to out making every top level character a [Aa] set

-	bool inRange = false;

-	while( *in )

-	{

-		if ( *in == '[' )

-			inRange = true;

-		if ( *in == ']' )

-			inRange = false;

-		if ( ! inRange && isalpha( *in ) )

-		{

-			*out++ = '[';

-			*out++ = (char)toupper( *in );

-			*out++ = (char)tolower( *in );

-			*out++ = ']';

-		}

-		else

-			*out++ = *in;

-		in++;

-	}

-	*out = 0;

-}

-

-// GetReplaceString	- Converts a replace expression to a string

-//					- perform substitutions after a regexp match

-// Returns			- The resultant string

-ivy::string regexp::GetReplaceString( const char* sReplaceExp ) const

-{

-	ivy::string szEmpty( "" );

-

-	char *src = (char *)sReplaceExp;

-	//char *buf;

-	char c;

-	int no;

-	size_t len;

-

-	if( sReplaceExp == NULL )

-	{

-		regerror( REGERR_NULL_TO_REGSUB  );

-		return szEmpty;

-	}

-	if ( *program != MAGIC)

-	{

-		regerror( REGERR_DAMAGED_REGEXP_REGSUB );

-		return szEmpty;

-	}

-

-	// First compute the length of the string

-	size_t replacelen = 0;

-	while ((c = *src++) != '\0') 

-	{

-		if (c == '&')

-			no = 0;

-		else if (c == '\\' && isdigit(*src))

-			no = *src++ - '0';

-		else

-			no = -1;

-

-		if (no < 0) 

-		{	

-			// Ordinary character. 

-			if (c == '\\' && (*src == '\\' || *src == '&'))

-				c = *src++;

-			replacelen++;

-		} 

-		else if (startp[no] != NULL && endp[no] != NULL &&

-					endp[no] > startp[no]) 

-		{

-			// Get tagged expression

-			len = endp[no] - startp[no];

-			replacelen += len;

-		}

-	}

-

-	ivy::string szReplace;

-

-	//buf = szReplace.GetBufferSetLength( replacelen );

-

-	// Now we can create the string

-	src = (char *)sReplaceExp;

-	while ((c = *src++) != '\0') 

-	{

-		if (c == '&')

-			no = 0;

-		else if (c == '\\' && isdigit(*src))

-			no = *src++ - '0';

-		else

-			no = -1;

-

-		if (no < 0) 

-		{	

-			// Ordinary character. 

-			if (c == '\\' && (*src == '\\' || *src == '&'))

-				c = *src++;

-			//*buf++ = c;

-			szReplace += c ;

-		} 

-		else if (startp[no] != NULL && endp[no] != NULL &&

-					endp[no] > startp[no]) 

-		{

-			// Get tagged expression

-			len = endp[no] - startp[no];

-			//strncpy(buf, startp[no], len);

-			//buf += len;

-			szReplace.append( startp[no], len );

-//			if (len != 0 && *(buf-1) == '\0' ))

-//			{	/* strncpy hit NUL. */

-//				regerror( REGERR_DAMAGED_MATCH_STRING );

-//				return szEmpty;

-//			}

-		}

-	}

-

-	//szReplace.ReleaseBuffer( replacelen );

-	return szReplace;

-}

-

-ivy::string Regexp::GetErrorString() const

-{

-	// make sure that if status == 0 that we have an error string

-	//assert( ( ! CompiledOK() ) ? ( rc ? rc->GetErrorString() : m_szError).length() != 0 : 1 );

-	return rc ? rc->GetErrorString() : m_szError ;

-}

-

-void Regexp::ClearErrorString() const

-{

-	if ( rc )

-		rc->ClearErrorString();

-	m_szError.erase();

-}

-