ncurses 5.3

[ncurses.git] / form / fty_regex.c

diff --git a/form/fty_regex.c b/form/fty_regex.c
index 3ad62e9f040ad6fdf6e5bd9cfb19e6dfc11a2295..6cb69d04675254dfe3547b3382b01151123feef3 100644 (file)
--- a/form/fty_regex.c
+++ b/form/fty_regex.c
@@ -7,15 +7,16 @@
  */
 /***************************************************************************
 *                                                                          *
-*  Author : Juergen Pfeifer, Juergen.Pfeifer@T-Online.de                   *
+*  Author : Juergen Pfeifer                                                *
+*  Contact: http://www.familiepfeifer.de/Contact.aspx?Lang=en              *
 *                                                                          *
 ***************************************************************************/
 
 #include "form.priv.h"
 
-MODULE_ID("$Id: fty_regex.c,v 1.9 1997/05/01 16:03:17 tom Exp $")
+MODULE_ID("$Id: fty_regex.c,v 1.16 2002/07/06 15:33:27 juergen Exp $")
 
-#if HAVE_REGEX_H       /* We prefer POSIX regex */
+#if HAVE_REGEX_H_FUNCS /* We prefer POSIX regex */
 #include <regex.h>
 
 typedef struct
@@ -24,7 +25,7 @@ typedef struct
   unsigned long *refCount;
 } RegExp_Arg;
 
-#elif HAVE_REGEXP_H | HAVE_REGEXPR_H
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
 #undef RETURN
 static int reg_errno;
 
@@ -47,7 +48,7 @@ static char *RegEx_Error(int code)
 #define RETURN(c)      return(c)
 #define ERROR(c)       return RegEx_Error(c)
 
-#if HAVE_REGEXP_H
+#if HAVE_REGEXP_H_FUNCS
 #include <regexp.h>
 #else
 #include <regexpr.h>
@@ -66,16 +67,16 @@ typedef struct
 #endif
 
 /*---------------------------------------------------------------------------
-|   Facility      :  libnform  
+|   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)
 {
-#if HAVE_REGEX_H
+#if HAVE_REGEX_H_FUNCS
   char *rx = va_arg(*ap,char *);
   RegExp_Arg *preg;
 
@@ -98,12 +99,12 @@ static void *Make_RegularExpression_Type(va_list * ap)
        }
     }
   return((void *)preg);
-#elif HAVE_REGEXP_H | HAVE_REGEXPR_H
+#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));
-  
+
   if (pArg)
     {
       int blen = RX_INCREMENT;
@@ -115,10 +116,10 @@ static void *Make_RegularExpression_Type(va_list * ap)
        char *buf = (char *)malloc(blen);
        if (buf)
          {
-#if HAVE_REGEXP_H
-           char *last_pos = compile (rx, buf, &buf[blen], '\0');
-#else
+#if HAVE_REGEXP_H_FUNCS
            char *last_pos = compile (rx, buf, &buf[blen], '\0');
+#else /* HAVE_REGEXPR_H_FUNCS */
+           char *last_pos = compile (rx, buf, &buf[blen]);
 #endif
            if (reg_errno)
              {
@@ -126,7 +127,7 @@ static void *Make_RegularExpression_Type(va_list * ap)
                if (reg_errno==50)
                  blen += RX_INCREMENT;
                else
-                 {                
+                 {
                    free(pArg);
                    pArg = NULL;
                    break;
@@ -152,54 +153,54 @@ static void *Make_RegularExpression_Type(va_list * ap)
 }
 
 /*---------------------------------------------------------------------------
-|   Facility      :  libnform  
+|   Facility      :  libnform
 |   Function      :  static void *Copy_RegularExpression_Type(
 |                                      const void * argp)
-|   
-|   Description   :  Copy structure for regex type argument.  
+|
+|   Description   :  Copy structure for regex type argument.
 |
 |   Return Values :  Pointer to argument structure or NULL on error.
 +--------------------------------------------------------------------------*/
 static void *Copy_RegularExpression_Type(const void * argp)
 {
-#if (HAVE_REGEX_H | HAVE_REGEXP_H | HAVE_REGEXPR_H)
+#if (HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS)
   const RegExp_Arg *ap = (const RegExp_Arg *)argp;
-  const RegExp_Arg *new = (const RegExp_Arg *)0; 
-  
+  const RegExp_Arg *result = (const RegExp_Arg *)0;
+
   if (ap)
     {
       *(ap->refCount) += 1;
-      new = ap;
+      result = ap;
     }
-  return (void *)new;
+  return (void *)result;
 #else
   return 0;
 #endif
 }
 
 /*---------------------------------------------------------------------------
-|   Facility      :  libnform  
+|   Facility      :  libnform
 |   Function      :  static void Free_RegularExpression_Type(void * argp)
-|   
+|
 |   Description   :  Free structure for regex type argument.
 |
 |   Return Values :  -
 +--------------------------------------------------------------------------*/
 static void Free_RegularExpression_Type(void * argp)
 {
-#if HAVE_REGEX_H | HAVE_REGEXP_H | HAVE_REGEXPR_H
+#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)
        {
-#if HAVE_REGEX_H
+#if HAVE_REGEX_H_FUNCS
          if (ap->pRegExp)
            {
              free(ap->refCount);
              regfree(ap->pRegExp);
            }
-#elif HAVE_REGEXP_H | HAVE_REGEXPR_H
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
          if (ap->compiled_expression)
            {
              free(ap->refCount);
@@ -213,11 +214,11 @@ static void Free_RegularExpression_Type(void * argp)
 }
 
 /*---------------------------------------------------------------------------
-|   Facility      :  libnform  
+|   Facility      :  libnform
 |   Function      :  static bool Check_RegularExpression_Field(
 |                                      FIELD * field,
 |                                      const void  * argp)
-|   
+|
 |   Description   :  Validate buffer content to be a valid regular expression
 |
 |   Return Values :  TRUE  - field is valid
@@ -226,11 +227,11 @@ static void Free_RegularExpression_Type(void * argp)
 static bool Check_RegularExpression_Field(FIELD * field, const void  * argp)
 {
   bool match = FALSE;
-#if HAVE_REGEX_H
+#if HAVE_REGEX_H_FUNCS
   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);
-#elif HAVE_REGEXP_H | HAVE_REGEXPR_H
+#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);
@@ -252,6 +253,6 @@ static FIELDTYPE typeREGEXP = {
   NULL
 };
 
-FIELDTYPE* TYPE_REGEXP = &typeREGEXP;
+NCURSES_EXPORT_VAR(FIELDTYPE*) TYPE_REGEXP = &typeREGEXP;
 
 /* fty_regex.c ends here */