Import a stock copy of ncurses 5.8 into the vendor space.

It seems both local changes we made to 5.7 have already been fixed
upstream properly, so there is no need to preserve the changes. Also,
with SVN we import full source trees. Unlike CVS, where we removed
unneeded cruft.

1 files changed, 108 insertions, 64 deletions

diff --git a/form/fty_regex.c b/form/fty_regex.c
index 247779f..2c0a4ca 100644
--- a/form/fty_regex.c
+++ b/form/fty_regex.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2009,2010 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            *
@@ -34,7 +34,7 @@
 
 #include "form.priv.h"
 
-MODULE_ID("$Id: fty_regex.c,v 1.21 2007/10/13 19:33:50 tom Exp $")
+MODULE_ID("$Id: fty_regex.c,v 1.24 2010/01/23 21:14:37 tom Exp $")
 
 #if HAVE_REGEX_H_FUNCS		/* We prefer POSIX regex */
 #include <regex.h>
@@ -90,97 +90,109 @@ RegExp_Arg;
 
 #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)
+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 = typeMalloc(RegExp_Arg, 1);
-
-  if (preg)
+  if (rx)
     {
-      T((T_CREATE("RegExp_Arg %p"), 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"), preg->pRegExp));
-	  preg->refCount = typeMalloc(unsigned long, 1);
+      preg = typeMalloc(RegExp_Arg, 1);
 
-	  *(preg->refCount) = 1;
-	}
-      else
+      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));
+	      preg->refCount = typeMalloc(unsigned long, 1);
+
+	      *(preg->refCount) = 1;
+	    }
+	  else
+	    {
+	      if (preg->pRegExp)
+		free(preg->pRegExp);
+	      free(preg);
+	      preg = (RegExp_Arg *)0;
+	    }
 	}
     }
   return ((void *)preg);
 #elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
-  char *rx = va_arg(*ap, char *);
-  RegExp_Arg *pArg;
+  char *rx = (char *)arg;
+  RegExp_Arg *pArg = (RegExp_Arg *)0;
 
-  pArg = typeMalloc(RegExp_Arg, 1);
-
-  if (pArg)
+  if (rx)
     {
-      int blen = RX_INCREMENT;
+      pArg = typeMalloc(RegExp_Arg, 1);
 
-      T((T_CREATE("RegExp_Arg %p"), pArg));
-      pArg->compiled_expression = NULL;
-      pArg->refCount = typeMalloc(unsigned long, 1);
+      if (pArg)
+	{
+	  int blen = RX_INCREMENT;
 
-      *(pArg->refCount) = 1;
+	  T((T_CREATE("RegExp_Arg %p"), pArg));
+	  pArg->compiled_expression = NULL;
+	  pArg->refCount = typeMalloc(unsigned long, 1);
 
-      do
-	{
-	  char *buf = typeMalloc(char, blen);
+	  *(pArg->refCount) = 1;
 
-	  if (buf)
+	  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;
+		  if (reg_errno)
+		    {
+		      free(buf);
+		      if (reg_errno == 50)
+			blen += RX_INCREMENT;
+		      else
+			{
+			  free(pArg);
+			  pArg = NULL;
+			  break;
+			}
+		    }
 		  else
 		    {
-		      free(pArg);
-		      pArg = NULL;
+		      pArg->compiled_expression = buf;
 		      break;
 		    }
 		}
-	      else
-		{
-		  pArg->compiled_expression = buf;
-		  break;
-		}
 	    }
+	  while (blen <= MAX_RX_LEN);
+	}
+      if (pArg && !pArg->compiled_expression)
+	{
+	  free(pArg);
+	  pArg = NULL;
 	}
-      while (blen <= MAX_RX_LEN);
-    }
-  if (pArg && !pArg->compiled_expression)
-    {
-      free(pArg);
-      pArg = NULL;
     }
   return (void *)pArg;
 #else
@@ -190,6 +202,22 @@ Make_RegularExpression_Type(va_list *ap)
 
 /*---------------------------------------------------------------------------
 |   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(
 |                                      const void * argp)
 |
@@ -198,7 +226,7 @@ Make_RegularExpression_Type(va_list *ap)
 |   Return Values :  Pointer to argument structure or NULL on error.
 +--------------------------------------------------------------------------*/
 static void *
-Copy_RegularExpression_Type(const void *argp)
+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;
@@ -224,7 +252,7 @@ Copy_RegularExpression_Type(const void *argp)
 |   Return Values :  -
 +--------------------------------------------------------------------------*/
 static void
-Free_RegularExpression_Type(void *argp)
+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;
@@ -264,7 +292,8 @@ Free_RegularExpression_Type(void *argp)
 |                    FALSE - field is invalid
 +--------------------------------------------------------------------------*/
 static bool
-Check_RegularExpression_Field(FIELD *field, const void *argp)
+Check_RegularExpression_Field(FIELD *field MAYBE_UNUSED,
+			      const void *argp MAYBE_UNUSED)
 {
   bool match = FALSE;
 
@@ -295,12 +324,27 @@ static FIELDTYPE typeREGEXP =
   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
 };
 
 NCURSES_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)
+*/
+NCURSES_EXPORT(FIELDTYPE *)
+_nc_TYPE_REGEXP(void)
+{
+  return TYPE_REGEXP;
+}
+#endif
+
 /* fty_regex.c ends here */