X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=form%2Ffty_regex.c;h=3a8b404714bf29fa95575aaaabdaad91e5ae0aa4;hp=7a928125d4adf594992d810d47e3761e9839c96f;hb=e5d1530ca229aef94a3c84ad33f8ae89f35c4045;hpb=0eb88fc5281804773e2a0c7a488a4452463535ce diff --git a/form/fty_regex.c b/form/fty_regex.c index 7a928125..3a8b4047 100644 --- a/form/fty_regex.c +++ b/form/fty_regex.c @@ -1,43 +1,75 @@ +/**************************************************************************** + * Copyright 2018,2020 Thomas E. Dickey * + * Copyright 1998-2012,2015 Free Software Foundation, Inc. * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the * + * "Software"), to deal in the Software without restriction, including * + * without limitation the rights to use, copy, modify, merge, publish, * + * distribute, distribute with modifications, sublicense, and/or sell * + * copies of the Software, and to permit persons to whom the Software is * + * furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included * + * in all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * + * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * + * * + * Except as contained in this notice, the name(s) of the above copyright * + * holders shall not be used in advertising or otherwise to promote the * + * sale, use or other dealings in this Software without prior written * + * authorization. * + ****************************************************************************/ -/* - * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT. - * You may freely copy it for use as a template for your own field types. - * If you develop a field type that might be of general use, please send - * it back to the ncurses maintainers for inclusion in the next version. - */ /*************************************************************************** * * -* Author : Juergen Pfeifer, juergen.pfeifer@gmx.net * +* Author : Juergen Pfeifer * * * ***************************************************************************/ #include "form.priv.h" -MODULE_ID("$Id: fty_regex.c,v 1.14 1999/05/16 17:23:38 juergen Exp $") +MODULE_ID("$Id: fty_regex.c,v 1.30 2020/05/24 01:40:20 anonymous.maarten Exp $") -#if HAVE_REGEX_H_FUNCS /* We prefer POSIX regex */ +#if HAVE_REGEX_H_FUNCS || HAVE_LIB_PCRE2 /* We prefer POSIX regex */ + +#if HAVE_PCRE2POSIX_H +#include +#elif HAVE_PCREPOSIX_H +#include +#else #include +#endif typedef struct -{ - regex_t *pRegExp; - unsigned long *refCount; -} RegExp_Arg; + { + regex_t *pRegExp; + unsigned long *refCount; + } +RegExp_Arg; #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS #undef RETURN static int reg_errno; -static char *RegEx_Init(char *instring) +static char * +RegEx_Init(char *instring) { - reg_errno = 0; - return instring; + reg_errno = 0; + return instring; } -static char *RegEx_Error(int code) +static char * +RegEx_Error(int code) { - reg_errno = code; - return 0; + reg_errno = code; + return 0; } #define INIT register char *sp = RegEx_Init(instring); @@ -57,7 +89,8 @@ typedef struct { char *compiled_expression; unsigned long *refCount; -} RegExp_Arg; +} +RegExp_Arg; /* Maximum Length we allow for a compiled regular expression */ #define MAX_RX_LEN (2048) @@ -65,85 +98,107 @@ typedef struct #endif +#if HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS +# define MAYBE_UNUSED +#else +# define MAYBE_UNUSED GCC_UNUSED +#endif + /*--------------------------------------------------------------------------- | Facility : libnform -| Function : static void *Make_RegularExpression_Type(va_list * ap) +| Function : static void *Generic_RegularExpression_Type(void * arg) | | Description : Allocate structure for regex type argument. | | Return Values : Pointer to argument structure or NULL on error +--------------------------------------------------------------------------*/ -static void *Make_RegularExpression_Type(va_list * ap) +static void * +Generic_RegularExpression_Type(void *arg MAYBE_UNUSED) { #if HAVE_REGEX_H_FUNCS - char *rx = va_arg(*ap,char *); - RegExp_Arg *preg; + char *rx = (char *)arg; + RegExp_Arg *preg = (RegExp_Arg *)0; - preg = (RegExp_Arg*)malloc(sizeof(RegExp_Arg)); - if (preg) + if (rx) { - if (((preg->pRegExp = (regex_t*)malloc(sizeof(regex_t))) != (regex_t*)0) - && !regcomp(preg->pRegExp,rx, - (REG_EXTENDED | REG_NOSUB | REG_NEWLINE) )) - { - preg->refCount = (unsigned long *)malloc(sizeof(unsigned long)); - *(preg->refCount) = 1; - } - else + preg = typeCalloc(RegExp_Arg, 1); + + if (preg) { - if (preg->pRegExp) - free(preg->pRegExp); - free(preg); - preg = (RegExp_Arg*)0; + T((T_CREATE("RegExp_Arg %p"), (void *)preg)); + if (((preg->pRegExp = typeMalloc(regex_t, 1)) != 0) + && !regcomp(preg->pRegExp, rx, + (REG_EXTENDED | REG_NOSUB | REG_NEWLINE))) + { + T((T_CREATE("regex_t %p"), (void *)preg->pRegExp)); + if ((preg->refCount = typeMalloc(unsigned long, 1)) != 0) + *(preg->refCount) = 1; + } + else + { + if (preg->pRegExp) + free(preg->pRegExp); + free(preg); + preg = (RegExp_Arg *)0; + } } } - return((void *)preg); + return ((void *)preg); #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS - char *rx = va_arg(*ap,char *); - RegExp_Arg *pArg; - - pArg = (RegExp_Arg *)malloc(sizeof(RegExp_Arg)); + char *rx = (char *)arg; + RegExp_Arg *pArg = (RegExp_Arg *)0; - if (pArg) + if (rx) { - int blen = RX_INCREMENT; - pArg->compiled_expression = NULL; - pArg->refCount = (unsigned long *)malloc(sizeof(unsigned long)); - *(pArg->refCount) = 1; - - do { - char *buf = (char *)malloc(blen); - if (buf) - { + pArg = typeMalloc(RegExp_Arg, 1); + + if (pArg) + { + int blen = RX_INCREMENT; + + T((T_CREATE("RegExp_Arg %p"), pArg)); + pArg->compiled_expression = NULL; + if ((pArg->refCount = typeMalloc(unsigned long, 1)) != 0) + *(pArg->refCount) = 1; + + do + { + char *buf = typeMalloc(char, blen); + + if (buf) + { #if HAVE_REGEXP_H_FUNCS - char *last_pos = compile (rx, buf, &buf[blen], '\0'); + char *last_pos = compile(rx, buf, &buf[blen], '\0'); + #else /* HAVE_REGEXPR_H_FUNCS */ - char *last_pos = compile (rx, buf, &buf[blen]); + char *last_pos = compile(rx, buf, &buf[blen]); #endif - if (reg_errno) - { - free(buf); - if (reg_errno==50) - blen += RX_INCREMENT; - else - { - free(pArg); - pArg = NULL; - break; - } - } - else - { - pArg->compiled_expression = buf; - break; - } - } - } while( blen <= MAX_RX_LEN ); - } - if (pArg && !pArg->compiled_expression) - { - free(pArg); - pArg = NULL; + if (reg_errno) + { + free(buf); + if (reg_errno == 50) + blen += RX_INCREMENT; + else + { + free(pArg); + pArg = NULL; + break; + } + } + else + { + pArg->compiled_expression = buf; + break; + } + } + } + while (blen <= MAX_RX_LEN); + } + if (pArg && !pArg->compiled_expression) + { + free(pArg); + pArg = NULL; + } } return (void *)pArg; #else @@ -151,6 +206,22 @@ static void *Make_RegularExpression_Type(va_list * ap) #endif } +/*--------------------------------------------------------------------------- +| Facility : libnform +| Function : static void *Make_RegularExpression_Type(va_list * ap) +| +| Description : Allocate structure for regex type argument. +| +| Return Values : Pointer to argument structure or NULL on error ++--------------------------------------------------------------------------*/ +static void * +Make_RegularExpression_Type(va_list *ap) +{ + char *rx = va_arg(*ap, char *); + + return Generic_RegularExpression_Type((void *)rx); +} + /*--------------------------------------------------------------------------- | Facility : libnform | Function : static void *Copy_RegularExpression_Type( @@ -160,7 +231,8 @@ static void *Make_RegularExpression_Type(va_list * ap) | | Return Values : Pointer to argument structure or NULL on error. +--------------------------------------------------------------------------*/ -static void *Copy_RegularExpression_Type(const void * argp) +static void * +Copy_RegularExpression_Type(const void *argp MAYBE_UNUSED) { #if (HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS) const RegExp_Arg *ap = (const RegExp_Arg *)argp; @@ -185,10 +257,12 @@ static void *Copy_RegularExpression_Type(const void * argp) | | Return Values : - +--------------------------------------------------------------------------*/ -static void Free_RegularExpression_Type(void * argp) +static void +Free_RegularExpression_Type(void *argp MAYBE_UNUSED) { #if HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS RegExp_Arg *ap = (RegExp_Arg *)argp; + if (ap) { if (--(*(ap->refCount)) == 0) @@ -198,6 +272,7 @@ static void Free_RegularExpression_Type(void * argp) { free(ap->refCount); regfree(ap->pRegExp); + free(ap->pRegExp); } #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS if (ap->compiled_expression) @@ -223,35 +298,60 @@ static void Free_RegularExpression_Type(void * argp) | Return Values : TRUE - field is valid | FALSE - field is invalid +--------------------------------------------------------------------------*/ -static bool Check_RegularExpression_Field(FIELD * field, const void * argp) +static bool +Check_RegularExpression_Field(FIELD *field MAYBE_UNUSED, + const void *argp MAYBE_UNUSED) { bool match = FALSE; + #if HAVE_REGEX_H_FUNCS - const RegExp_Arg *ap = (const RegExp_Arg*)argp; + const RegExp_Arg *ap = (const RegExp_Arg *)argp; + if (ap && ap->pRegExp) - match = (regexec(ap->pRegExp,field_buffer(field,0),0,NULL,0) ? FALSE:TRUE); + match = (regexec(ap->pRegExp, field_buffer(field, 0), 0, NULL, 0) + ? FALSE + : TRUE); #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS RegExp_Arg *ap = (RegExp_Arg *)argp; + if (ap && ap->compiled_expression) - match = (step(field_buffer(field,0),ap->compiled_expression) ? TRUE:FALSE); + match = (step(field_buffer(field, 0), ap->compiled_expression) + ? TRUE + : FALSE); #endif return match; } -static FIELDTYPE typeREGEXP = { +static FIELDTYPE typeREGEXP = +{ _HAS_ARGS | _RESIDENT, - 1, /* this is mutable, so we can't be const */ + 1, /* this is mutable, so we can't be const */ (FIELDTYPE *)0, (FIELDTYPE *)0, Make_RegularExpression_Type, Copy_RegularExpression_Type, Free_RegularExpression_Type, - Check_RegularExpression_Field, - NULL, - NULL, - NULL + INIT_FT_FUNC(Check_RegularExpression_Field), + INIT_FT_FUNC(NULL), + INIT_FT_FUNC(NULL), + INIT_FT_FUNC(NULL), +#if NCURSES_INTEROP_FUNCS + Generic_RegularExpression_Type +#endif }; -FIELDTYPE* TYPE_REGEXP = &typeREGEXP; +FORM_EXPORT_VAR(FIELDTYPE*) TYPE_REGEXP = &typeREGEXP; + +#if NCURSES_INTEROP_FUNCS +/* The next routines are to simplify the use of ncurses from + programming languages with restictions on interop with C level + constructs (e.g. variable access or va_list + ellipsis constructs) +*/ +FORM_EXPORT(FIELDTYPE *) +_nc_TYPE_REGEXP(void) +{ + return TYPE_REGEXP; +} +#endif /* fty_regex.c ends here */