swish-e/src/swregex.c

/*
$Id: swregex.c,v 1.1 2002/03/17 03:54:19 whmoseley Exp $
**
**
** This program and library is free software; you can redistribute it and/or
** modify it under the terms of the GNU (Library) General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU (Library) General Public License for more details.
**
** You should have received a copy of the GNU (Library) General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
**---------------------------------------------------------
**
**
** March 16, 2002 - Bill Moseley: moved regex routines out of string.c
**
** This is a collection of routines for building and testing regular expressions
** for use with swish-e.
**
*/

//#include <ctype.h>
#include "swish.h"
#include "mem.h"
//#include "index.h"
//#include "swish_qsort.h"
#include "string.h"
#include "error.h"
#include "swregex.h"

static char *regex_replace( char *str, regex_list *regex, int offset, int *matched );


/*********************************************************************
*   Adds a list of patterns to a reg_list.  Calls progerr on failure.
*   Call With:
*       name        = Descriptive name for errors - e.g. the name of the directive currently being processed
*       regex_list  = pointer to the list of regular expressions
*       params      = null-terminated list of pointers to strings
*       regex_pattern = flag to indicate that it's a delimited pattern (instead of just the pattern)
*
*   Returns:
*       void
*
*   ToDO:
*       Really should get passed in *SWISH so can set error string and return
*
*   Notes:
*       An expression can be proceeded by the word "not" to negate the matching of the pattern.
*   
*
**********************************************************************/
void add_regex_patterns( char *name, regex_list **reg_list, char **params, int regex_pattern )
{
    int     negate;
    char    *word;
    char    *pos;
    char    *ptr;
    int     delimiter;
    int     cflags;
    int     global;
    

    while ( *params )
    {
        negate = 0;
        global = 0;
        cflags = REG_EXTENDED;

        
        if ( (strcasecmp( *params, "not" ) == 0) && *(params+1) )
        {
            negate = 1;
            params++;
        }

        /* Simple case of a string pattern */
        if ( !regex_pattern )
        {
            add_regular_expression( reg_list, *params, NULL, cflags, global, negate );
            params++;
            continue;
        }

        word = *params;       
        delimiter = (int)*word;

        word++; /* past the first delimiter */

        if ( !(pos = strchr( word, delimiter )))
            progerr("%s regex: failed to find search pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, *params );

        *pos = '\0';            


        /* now check for flags */
        for ( ptr = pos + 1; *ptr; ptr++ )
        {
            if ( *ptr == 'i' )
                cflags |= REG_ICASE;
            else if ( *ptr == 'm' )
                cflags |= REG_NEWLINE;
            else
                progerr("%s regexp %s: unknown flag '%c'", name, *params, *ptr );
        }

        add_regular_expression( reg_list, word, NULL, cflags, global, negate );

        *pos = delimiter;  /* put it back */
        params++;
    }
}

/*********************************************************************
*   Adds a single regex replacement pattern
*
*   Call With:
*       name        = Descriptive name for errors - e.g. the name of the directive currently being processed
*       regex_list  = pointer to the list of regular expressions
*       word        = delimited regex pattern
*
*   Returns:
*       void
*
*
*
**********************************************************************/

void  add_replace_expression( char *name, regex_list **reg_list, char *expression )
   
{
    char    *word = estrdup( expression );
    char    *save = word;
    int     delimiter = (int)*word;
    char    *pos;
    char    *pattern = NULL;
    char    *replace = NULL;
    int     cflags = REG_EXTENDED;
    int     global = 0;
    char    *ptr;
    

    word++; /* past the first delimiter */

    if ( !(pos = strchr( word, delimiter )))
        progerr("%s regex: failed to find search pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, word );

    *pos = '\0';            
    pattern = estrdup(word);

    word = pos + 1;  /* now at replace pattern */

    if ( !(pos = strchr( word, delimiter )))
        progerr("%s regex: failed to find replace pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, word );

    *pos = '\0';            
    replace = estrdup(word);


    /* now check for flags */
    for ( ptr = pos + 1; *ptr; ptr++ )
    {
        if ( *ptr == 'i' )
            cflags |= REG_ICASE;

        else if ( *ptr == 'm' )
            cflags |= REG_NEWLINE;

        else if ( *ptr == 'g' )
            global++;
        else
            progerr("%s regexp %s: unknown flag '%c'", name, expression, *ptr );
    }

    add_regular_expression( reg_list, pattern, replace, cflags, global, 0 );

    efree( pattern );
    efree( replace );
    efree( save );
}


/*********************************************************************
*   Match regular expressions
*   Works on a list of expressions, and returns true if *ANY* match
*   
*
**********************************************************************/
int match_regex_list( char *str, regex_list *regex )
{
    regmatch_t pmatch[1];
    int        matched;

    while ( regex )
    {
        matched = regex->negate
            ? regexec(&regex->re, str, (size_t) 1, pmatch, 0) != 0
            : regexec(&regex->re, str, (size_t) 1, pmatch, 0) == 0;

        if ( DEBUG_MASK & DEBUG_REGEX )
            printf("match %s %c~ m[%s] : %s\n", str, (int)(regex->negate ? '!' : '='), regex->pattern, matched ? "matched" : "nope" );            

        if ( matched )
            return 1;

        regex = regex->next;            
    }

    return 0;
}


/*********************************************************************
*   Process all the regular expressions in a regex_list
*
*
**********************************************************************/
char *process_regex_list( char *str, regex_list *regex, int *matched )
{
    if ( DEBUG_MASK & DEBUG_REGEX && regex )
        printf("\nOriginal String: '%s'\n", str );

    while ( regex )
    {
        str = regex_replace( str, regex, 0, matched );
        regex = regex->next;

        if ( DEBUG_MASK & DEBUG_REGEX )
            printf("  Result String: '%s'\n", str );

    }

    return str;
}

/*********************************************************************
*  Regular Expression Substitution
*
*   Rewritten 7/31/2001 - general purpose regexp
*
*   Pass in a string and a regex_list pointer
*
*   Returns:
*       a string.  Either the original, or a replacement string
*       Frees passed in string if return is different.
*
*   Notes:
*       Clearly, there must be a library to do this already.  For /g I'm
*       recursively calling this.
*
*
**********************************************************************/
static char *regex_replace( char *str, regex_list *regex, int offset, int *matched )
{
    regmatch_t pmatch[MAXPAR];
    char   *c;
    char   *newstr;
    int     escape = 0;
    int     pos = 0;
    int     j;
    int     last_offset = 0;

    if ( DEBUG_MASK & DEBUG_REGEX )
        printf("replace %s =~ m[%s][%s]: %s\n", str + offset, regex->pattern, regex->replace,
                regexec(&regex->re, str + offset, (size_t) MAXPAR, pmatch, 0) ? "No Match" : "Matched" );
    
    /* Run regex - return original string if no match (might be nice to print error msg? */
    if ( regexec(&regex->re, str + offset, (size_t) MAXPAR, pmatch, 0) )
        return str;


    /* Flag that a pattern matched */
    (*matched)++;        


    /* allocate a string long enough */
    newstr = (char *) emalloc( offset + strlen( str ) + regex->replace_length + (regex->replace_count * strlen( str )) + 1 );

    /* Copy everything before string */
    for ( j=0; j < offset; j++ )
        newstr[pos++] = str[j];


    /* Copy everything before the match */
    if ( pmatch[0].rm_so > 0 )
        for ( j = offset; j < pmatch[0].rm_so + offset; j++ )
            newstr[pos++] = str[j];


    /* ugly section */
    for ( c = regex->replace; *c; c++ )
    {
        if ( escape )
        {
            newstr[pos++] = *c;
            last_offset = pos;
            escape = 0;
            continue;
        }
        
        if ( *c == '\\' && *(c+1) )
        {
            escape = 1;
            continue;
        }

        if ( '$' == *c && *(c+1) )
        {
            char   *start = NULL;
            char   *end = NULL;

            c++;

            /* chars before match */
            if ( '`' == *c  ) 
            {
                if ( pmatch[0].rm_so + offset > 0 )
                {
                    start = str;
                    end   = str + pmatch[0].rm_so + offset;
                }
            }

            /* chars after match */
            else if ( '\'' == *c )
            {
                start = str + pmatch[0].rm_eo + offset;
                end = str + strlen( str );
            }

            else if ( *c >= '0' && *c <= '9' )
            {
                int i = (int)( *c ) - (int)'0';

                if ( pmatch[i].rm_so != -1 )
                {
                    start = str + pmatch[i].rm_so + offset;
                    end   = str + pmatch[i].rm_eo + offset;
                }
            }

            else  /* just copy the pattern */
            {
                start = c - 1;
                end   = c + 1;
            }

            if ( start )
                for ( ; start < end; start++ )
                    newstr[pos++] = *start;
        }

        /* not a replace pattern, just copy the char */
        else
            newstr[pos++] = *c;

        last_offset = pos;
    }

    newstr[pos] = '\0';

    /* Append any pattern after the string */
    strcat( newstr, str+pmatch[0].rm_eo + offset );
    

    efree( str );
    

    /* This allow /g processing to match repeatedly */
    /* I'm sure there a way to mess this up and end up with a regex loop... */
    
    if ( regex->global && last_offset < strlen( newstr ) )
        newstr = regex_replace( newstr, regex, last_offset, matched );

    return newstr;
}

/*********************************************************
*  Free a regular express list
*
*********************************************************/

void free_regex_list( regex_list **reg_list )
{
    regex_list *list = *reg_list;
    regex_list *next;
    while ( list )
    {
        if ( list->replace )
            efree( list->replace );

        if ( list->pattern )
            efree( list->pattern );

        regfree(&list->re);

        next = list->next;
        efree( list );
        list = next;
    }
    *reg_list = NULL;
}
        
/****************************************************************************
*  Create or Add a regular expression to a list
*  pre-compiles expression to check for errors and for speed
*
*  Pattern and replace string passed in are duplicated
*
*
*****************************************************************************/

void add_regular_expression( regex_list **reg_list, char *pattern, char *replace, int cflags, int global, int negate )
{
    regex_list *new_node = emalloc( sizeof( regex_list ) );
    regex_list *last;
    char       *c;
    int         status;
    int         escape = 0;

    if ( (status = regcomp( &new_node->re, pattern, cflags )))
        progerr("Failed to complie regular expression '%s', pattern. Error: %d", pattern, status );


    new_node->pattern = pattern ? estrdup(pattern) : estrdup("");  /* only used for -T debugging */
    new_node->replace = replace ? estrdup(replace) : estrdup("");
    new_node->negate  = negate;

    new_node->global = global;  /* repeat flag */

    new_node->replace_length = strlen( new_node->replace );

    new_node->replace_count = 0;
    for ( c = new_node->replace; *c; c++ )
    {
        if ( escape )
        {
            escape = 0;
            continue;
        }
        
        if ( *c == '\\' )
        {
            escape = 1;
            continue;
        }

        if ( *c == '$' && *(c+1) )
            new_node->replace_count++;
    }
         
            
    new_node->next = NULL;


    if ( *reg_list == NULL )
        *reg_list = new_node;
    else
    {
        /* get end of list */
        for ( last = *reg_list; last->next; last = last->next );

        last->next = new_node;
    }

}

1	/*
2	$Id: swregex.c,v 1.1 2002/03/17 03:54:19 whmoseley Exp $
3	**
4	**
5	** This program and library is free software; you can redistribute it and/or
6	** modify it under the terms of the GNU (Library) General Public License
7	** as published by the Free Software Foundation; either version 2
8	** of the License, or any later version.
9	**
10	** This program is distributed in the hope that it will be useful,
11	** but WITHOUT ANY WARRANTY; without even the implied warranty of
12	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	** GNU (Library) General Public License for more details.
14	**
15	** You should have received a copy of the GNU (Library) General Public License
16	** along with this program; if not, write to the Free Software
17	** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18	**---------------------------------------------------------
19	**
20	**
21	** March 16, 2002 - Bill Moseley: moved regex routines out of string.c
22	**
23	** This is a collection of routines for building and testing regular expressions
24	** for use with swish-e.
25	**
26	*/
27
28	//#include <ctype.h>
29	#include "swish.h"
30	#include "mem.h"
31	//#include "index.h"
32	//#include "swish_qsort.h"
33	#include "string.h"
34	#include "error.h"
35	#include "swregex.h"
36
37	static char regex_replace( char str, regex_list regex, int offset, int matched );
38
39
40	/*********************************************************************
41	* Adds a list of patterns to a reg_list. Calls progerr on failure.
42	* Call With:
43	* name = Descriptive name for errors - e.g. the name of the directive currently being processed
44	* regex_list = pointer to the list of regular expressions
45	* params = null-terminated list of pointers to strings
46	* regex_pattern = flag to indicate that it's a delimited pattern (instead of just the pattern)
47	*
48	* Returns:
49	* void
50	*
51	* ToDO:
52	* Really should get passed in *SWISH so can set error string and return
53	*
54	* Notes:
55	* An expression can be proceeded by the word "not" to negate the matching of the pattern.
56	*
57	*
58	**********************************************************************/
59	void add_regex_patterns( char name, regex_list reg_list, char *params, int regex_pattern )
60	{
61	int negate;
62	char *word;
63	char *pos;
64	char *ptr;
65	int delimiter;
66	int cflags;
67	int global;
68
69
70	while ( *params )
71	{
72	negate = 0;
73	global = 0;
74	cflags = REG_EXTENDED;
75
76
77	if ( (strcasecmp( params, "not" ) == 0) && (params+1) )
78	{
79	negate = 1;
80	params++;
81	}
82
83	/* Simple case of a string pattern */
84	if ( !regex_pattern )
85	{
86	add_regular_expression( reg_list, *params, NULL, cflags, global, negate );
87	params++;
88	continue;
89	}
90
91	word = *params;
92	delimiter = (int)*word;
93
94	word++; /* past the first delimiter */
95
96	if ( !(pos = strchr( word, delimiter )))
97	progerr("%s regex: failed to find search pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, *params );
98
99	*pos = '\0';
100
101
102	/* now check for flags */
103	for ( ptr = pos + 1; *ptr; ptr++ )
104	{
105	if ( *ptr == 'i' )
106	cflags \|= REG_ICASE;
107	else if ( *ptr == 'm' )
108	cflags \|= REG_NEWLINE;
109	else
110	progerr("%s regexp %s: unknown flag '%c'", name, params, ptr );
111	}
112
113	add_regular_expression( reg_list, word, NULL, cflags, global, negate );
114
115	pos = delimiter; / put it back */
116	params++;
117	}
118	}
119
120	/*********************************************************************
121	* Adds a single regex replacement pattern
122	*
123	* Call With:
124	* name = Descriptive name for errors - e.g. the name of the directive currently being processed
125	* regex_list = pointer to the list of regular expressions
126	* word = delimited regex pattern
127	*
128	* Returns:
129	* void
130	*
131	*
132	*
133	**********************************************************************/
134
135	void add_replace_expression( char name, regex_list reg_list, char expression )
136
137	{
138	char *word = estrdup( expression );
139	char *save = word;
140	int delimiter = (int)*word;
141	char *pos;
142	char *pattern = NULL;
143	char *replace = NULL;
144	int cflags = REG_EXTENDED;
145	int global = 0;
146	char *ptr;
147
148
149	word++; /* past the first delimiter */
150
151	if ( !(pos = strchr( word, delimiter )))
152	progerr("%s regex: failed to find search pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, word );
153
154	*pos = '\0';
155	pattern = estrdup(word);
156
157	word = pos + 1; /* now at replace pattern */
158
159	if ( !(pos = strchr( word, delimiter )))
160	progerr("%s regex: failed to find replace pattern delimiter '%c' in pattern '%s'", name, (char)delimiter, word );
161
162	*pos = '\0';
163	replace = estrdup(word);
164
165
166	/* now check for flags */
167	for ( ptr = pos + 1; *ptr; ptr++ )
168	{
169	if ( *ptr == 'i' )
170	cflags \|= REG_ICASE;
171
172	else if ( *ptr == 'm' )
173	cflags \|= REG_NEWLINE;
174
175	else if ( *ptr == 'g' )
176	global++;
177	else
178	progerr("%s regexp %s: unknown flag '%c'", name, expression, *ptr );
179	}
180
181	add_regular_expression( reg_list, pattern, replace, cflags, global, 0 );
182
183	efree( pattern );
184	efree( replace );
185	efree( save );
186	}
187
188
189
190	/*********************************************************************
191	* Match regular expressions
192	* Works on a list of expressions, and returns true if ANY match
193	*
194	*
195	**********************************************************************/
196	int match_regex_list( char str, regex_list regex )
197	{
198	regmatch_t pmatch[1];
199	int matched;
200
201	while ( regex )
202	{
203	matched = regex->negate
204	? regexec(&regex->re, str, (size_t) 1, pmatch, 0) != 0
205	: regexec(&regex->re, str, (size_t) 1, pmatch, 0) == 0;
206
207	if ( DEBUG_MASK & DEBUG_REGEX )
208	printf("match %s %c~ m[%s] : %s\n", str, (int)(regex->negate ? '!' : '='), regex->pattern, matched ? "matched" : "nope" );
209
210	if ( matched )
211	return 1;
212
213	regex = regex->next;
214	}
215
216	return 0;
217	}
218
219
220	/*********************************************************************
221	* Process all the regular expressions in a regex_list
222	*
223	*
224	**********************************************************************/
225	char process_regex_list( char str, regex_list regex, int matched )
226	{
227	if ( DEBUG_MASK & DEBUG_REGEX && regex )
228	printf("\nOriginal String: '%s'\n", str );
229
230	while ( regex )
231	{
232	str = regex_replace( str, regex, 0, matched );
233	regex = regex->next;
234
235	if ( DEBUG_MASK & DEBUG_REGEX )
236	printf(" Result String: '%s'\n", str );
237
238	}
239
240	return str;
241	}
242
243	/*********************************************************************
244	* Regular Expression Substitution
245	*
246	* Rewritten 7/31/2001 - general purpose regexp
247	*
248	* Pass in a string and a regex_list pointer
249	*
250	* Returns:
251	* a string. Either the original, or a replacement string
252	* Frees passed in string if return is different.
253	*
254	* Notes:
255	* Clearly, there must be a library to do this already. For /g I'm
256	* recursively calling this.
257	*
258	*
259	**********************************************************************/
260	static char regex_replace( char str, regex_list regex, int offset, int matched )
261	{
262	regmatch_t pmatch[MAXPAR];
263	char *c;
264	char *newstr;
265	int escape = 0;
266	int pos = 0;
267	int j;
268	int last_offset = 0;
269
270	if ( DEBUG_MASK & DEBUG_REGEX )
271	printf("replace %s =~ m[%s][%s]: %s\n", str + offset, regex->pattern, regex->replace,
272	regexec(&regex->re, str + offset, (size_t) MAXPAR, pmatch, 0) ? "No Match" : "Matched" );
273
274	/* Run regex - return original string if no match (might be nice to print error msg? */
275	if ( regexec(&regex->re, str + offset, (size_t) MAXPAR, pmatch, 0) )
276	return str;
277
278
279	/* Flag that a pattern matched */
280	(*matched)++;
281
282
283	/* allocate a string long enough */
284	newstr = (char ) emalloc( offset + strlen( str ) + regex->replace_length + (regex->replace_count strlen( str )) + 1 );
285
286	/* Copy everything before string */
287	for ( j=0; j < offset; j++ )
288	newstr[pos++] = str[j];
289
290
291	/* Copy everything before the match */
292	if ( pmatch[0].rm_so > 0 )
293	for ( j = offset; j < pmatch[0].rm_so + offset; j++ )
294	newstr[pos++] = str[j];
295
296
297	/* ugly section */
298	for ( c = regex->replace; *c; c++ )
299	{
300	if ( escape )
301	{
302	newstr[pos++] = *c;
303	last_offset = pos;
304	escape = 0;
305	continue;
306	}
307
308	if ( c == '\\' && (c+1) )
309	{
310	escape = 1;
311	continue;
312	}
313
314	if ( '$' == c && (c+1) )
315	{
316	char *start = NULL;
317	char *end = NULL;
318
319	c++;
320
321	/* chars before match */
322	if ( '`' == *c )
323	{
324	if ( pmatch[0].rm_so + offset > 0 )
325	{
326	start = str;
327	end = str + pmatch[0].rm_so + offset;
328	}
329	}
330
331	/* chars after match */
332	else if ( '\'' == *c )
333	{
334	start = str + pmatch[0].rm_eo + offset;
335	end = str + strlen( str );
336	}
337
338	else if ( c >= '0' && c <= '9' )
339	{
340	int i = (int)( *c ) - (int)'0';
341
342	if ( pmatch[i].rm_so != -1 )
343	{
344	start = str + pmatch[i].rm_so + offset;
345	end = str + pmatch[i].rm_eo + offset;
346	}
347	}
348
349	else /* just copy the pattern */
350	{
351	start = c - 1;
352	end = c + 1;
353	}
354
355	if ( start )
356	for ( ; start < end; start++ )
357	newstr[pos++] = *start;
358	}
359
360	/* not a replace pattern, just copy the char */
361	else
362	newstr[pos++] = *c;
363
364	last_offset = pos;
365	}
366
367	newstr[pos] = '\0';
368
369	/* Append any pattern after the string */
370	strcat( newstr, str+pmatch[0].rm_eo + offset );
371
372
373	efree( str );
374
375
376	/* This allow /g processing to match repeatedly */
377	/* I'm sure there a way to mess this up and end up with a regex loop... */
378
379	if ( regex->global && last_offset < strlen( newstr ) )
380	newstr = regex_replace( newstr, regex, last_offset, matched );
381
382	return newstr;
383	}
384
385	/*********************************************************
386	* Free a regular express list
387	*
388	*********************************************************/
389
390	void free_regex_list( regex_list **reg_list )
391	{
392	regex_list list = reg_list;
393	regex_list *next;
394	while ( list )
395	{
396	if ( list->replace )
397	efree( list->replace );
398
399	if ( list->pattern )
400	efree( list->pattern );
401
402	regfree(&list->re);
403
404	next = list->next;
405	efree( list );
406	list = next;
407	}
408	*reg_list = NULL;
409	}
410
411	/****************************************************************************
412	* Create or Add a regular expression to a list
413	* pre-compiles expression to check for errors and for speed
414	*
415	* Pattern and replace string passed in are duplicated
416	*
417	*
418	*****************************************************************************/
419
420	void add_regular_expression( regex_list *reg_list, char pattern, char *replace, int cflags, int global, int negate )
421	{
422	regex_list *new_node = emalloc( sizeof( regex_list ) );
423	regex_list *last;
424	char *c;
425	int status;
426	int escape = 0;
427
428	if ( (status = regcomp( &new_node->re, pattern, cflags )))
429	progerr("Failed to complie regular expression '%s', pattern. Error: %d", pattern, status );
430
431
432
433	new_node->pattern = pattern ? estrdup(pattern) : estrdup(""); /* only used for -T debugging */
434	new_node->replace = replace ? estrdup(replace) : estrdup("");
435	new_node->negate = negate;
436
437	new_node->global = global; /* repeat flag */
438
439	new_node->replace_length = strlen( new_node->replace );
440
441	new_node->replace_count = 0;
442	for ( c = new_node->replace; *c; c++ )
443	{
444	if ( escape )
445	{
446	escape = 0;
447	continue;
448	}
449
450	if ( *c == '\\' )
451	{
452	escape = 1;
453	continue;
454	}
455
456	if ( c == '$' && (c+1) )
457	new_node->replace_count++;
458	}
459
460
461	new_node->next = NULL;
462
463
464	if ( *reg_list == NULL )
465	*reg_list = new_node;
466	else
467	{
468	/* get end of list */
469	for ( last = *reg_list; last->next; last = last->next );
470
471	last->next = new_node;
472	}
473
474	}
475