1 /****************************************************************************
2 * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc. *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *
12 * The above copyright notice and this permission notice shall be included *
13 * in all copies or substantial portions of the Software. *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 * Except as contained in this notice, the name(s) of the above copyright *
24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
27 ****************************************************************************/
29 /***************************************************************************
31 * Author : Juergen Pfeifer *
33 ***************************************************************************/
35 #include "form.priv.h"
37 MODULE_ID("$Id: fty_regex.c,v 1.21 2007/10/13 19:33:50 tom Exp $")
39 #if HAVE_REGEX_H_FUNCS /* We prefer POSIX regex */
45 unsigned long *refCount
;
49 #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
54 RegEx_Init(char *instring
)
67 #define INIT register char *sp = RegEx_Init(instring);
68 #define GETC() (*sp++)
70 #define UNGETC(c) (--sp)
71 #define RETURN(c) return(c)
72 #define ERROR(c) return RegEx_Error(c)
74 #if HAVE_REGEXP_H_FUNCS
82 char *compiled_expression
;
83 unsigned long *refCount
;
87 /* Maximum Length we allow for a compiled regular expression */
88 #define MAX_RX_LEN (2048)
89 #define RX_INCREMENT (256)
93 /*---------------------------------------------------------------------------
95 | Function : static void *Make_RegularExpression_Type(va_list * ap)
97 | Description : Allocate structure for regex type argument.
99 | Return Values : Pointer to argument structure or NULL on error
100 +--------------------------------------------------------------------------*/
102 Make_RegularExpression_Type(va_list *ap
)
104 #if HAVE_REGEX_H_FUNCS
105 char *rx
= va_arg(*ap
, char *);
108 preg
= typeMalloc(RegExp_Arg
, 1);
112 T((T_CREATE("RegExp_Arg %p"), preg
));
113 if (((preg
->pRegExp
= typeMalloc(regex_t
, 1)) != 0)
114 && !regcomp(preg
->pRegExp
, rx
,
115 (REG_EXTENDED
| REG_NOSUB
| REG_NEWLINE
)))
117 T((T_CREATE("regex_t %p"), preg
->pRegExp
));
118 preg
->refCount
= typeMalloc(unsigned long, 1);
120 *(preg
->refCount
) = 1;
127 preg
= (RegExp_Arg
*)0;
130 return ((void *)preg
);
131 #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
132 char *rx
= va_arg(*ap
, char *);
135 pArg
= typeMalloc(RegExp_Arg
, 1);
139 int blen
= RX_INCREMENT
;
141 T((T_CREATE("RegExp_Arg %p"), pArg
));
142 pArg
->compiled_expression
= NULL
;
143 pArg
->refCount
= typeMalloc(unsigned long, 1);
145 *(pArg
->refCount
) = 1;
149 char *buf
= typeMalloc(char, blen
);
153 #if HAVE_REGEXP_H_FUNCS
154 char *last_pos
= compile(rx
, buf
, &buf
[blen
], '\0');
156 #else /* HAVE_REGEXPR_H_FUNCS */
157 char *last_pos
= compile(rx
, buf
, &buf
[blen
]);
163 blen
+= RX_INCREMENT
;
173 pArg
->compiled_expression
= buf
;
178 while (blen
<= MAX_RX_LEN
);
180 if (pArg
&& !pArg
->compiled_expression
)
191 /*---------------------------------------------------------------------------
192 | Facility : libnform
193 | Function : static void *Copy_RegularExpression_Type(
196 | Description : Copy structure for regex type argument.
198 | Return Values : Pointer to argument structure or NULL on error.
199 +--------------------------------------------------------------------------*/
201 Copy_RegularExpression_Type(const void *argp
)
203 #if (HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS)
204 const RegExp_Arg
*ap
= (const RegExp_Arg
*)argp
;
205 const RegExp_Arg
*result
= (const RegExp_Arg
*)0;
209 *(ap
->refCount
) += 1;
212 return (void *)result
;
218 /*---------------------------------------------------------------------------
219 | Facility : libnform
220 | Function : static void Free_RegularExpression_Type(void * argp)
222 | Description : Free structure for regex type argument.
225 +--------------------------------------------------------------------------*/
227 Free_RegularExpression_Type(void *argp
)
229 #if HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
230 RegExp_Arg
*ap
= (RegExp_Arg
*)argp
;
234 if (--(*(ap
->refCount
)) == 0)
236 #if HAVE_REGEX_H_FUNCS
240 regfree(ap
->pRegExp
);
242 #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
243 if (ap
->compiled_expression
)
246 free(ap
->compiled_expression
);
255 /*---------------------------------------------------------------------------
256 | Facility : libnform
257 | Function : static bool Check_RegularExpression_Field(
261 | Description : Validate buffer content to be a valid regular expression
263 | Return Values : TRUE - field is valid
264 | FALSE - field is invalid
265 +--------------------------------------------------------------------------*/
267 Check_RegularExpression_Field(FIELD
*field
, const void *argp
)
271 #if HAVE_REGEX_H_FUNCS
272 const RegExp_Arg
*ap
= (const RegExp_Arg
*)argp
;
274 if (ap
&& ap
->pRegExp
)
275 match
= (regexec(ap
->pRegExp
, field_buffer(field
, 0), 0, NULL
, 0)
278 #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
279 RegExp_Arg
*ap
= (RegExp_Arg
*)argp
;
281 if (ap
&& ap
->compiled_expression
)
282 match
= (step(field_buffer(field
, 0), ap
->compiled_expression
)
289 static FIELDTYPE typeREGEXP
=
291 _HAS_ARGS
| _RESIDENT
,
292 1, /* this is mutable, so we can't be const */
295 Make_RegularExpression_Type
,
296 Copy_RegularExpression_Type
,
297 Free_RegularExpression_Type
,
298 Check_RegularExpression_Field
,
304 NCURSES_EXPORT_VAR(FIELDTYPE
*) TYPE_REGEXP
= &typeREGEXP
;
306 /* fty_regex.c ends here */