Re: Compile error in argz.c

[Bruno Haible]

Gisle Vanem wrote:
> The use of '__argv' as parameter names, causes this
> error from clang-cl:
>    argz.c(234,1): error: conflicting types for 'argz_extract'
>    argz_extract (const char *argz, size_t len, char **argv)
>    ^
>    .\argz.h(68,13): note: previous declaration is here
>    extern void argz_extract (const char *restrict __argz, size_t __len,
>                ^
>    argz.c(251,1): error: conflicting types for 'argz_create'
>    argz_create (char *const argv[], char **argz, size_t *len)
>    ^
>    .\argz.h(48,16): note: previous declaration is here
>    extern error_t argz_create (char *const __argv[], char **restrict __argz,
>                 ^
> 
> '__argv' is a macro in Windows' <stdlib.h> that expands
> to '(*__p___argv())'.
> 
> I could tweak it by a '#undef __argv' first, but...

Identifiers that start with '__' are in the system's namespace, that is,
owned by the libc and compiler vendors. Therefore, gnulib should not assume
that they are not defined as macros, nor interfere with them.

Also, let me remove
  - A 'const' definition, meant to work with K&R C compilers (from before 1990),
  - A duplicate function definition that, fortunately, has never been visible.


2020-05-26  Bruno Haible  <address@hidden>

        argz: Avoid name clashes through argz.h.
        Reported by Gisle Vanem <address@hidden> in
        <https://lists.gnu.org/archive/html/bug-gnulib/2020-05/msg00308.html>.
        * lib/argz.h: Don't use __ prefixed identifiers.
        (const): Remove definition.
        (argz_next): Remove inline definitions.

diff --git a/lib/argz.in.h b/lib/argz.in.h
index 061e3e5..4ca95cb 100644
--- a/lib/argz.in.h
+++ b/lib/argz.in.h
@@ -22,11 +22,7 @@
 
 #define __need_error_t
 #include <errno.h>
-#include <string.h>             /* Need size_t, and strchr is called below.  */
-
-#ifndef const
-# define const const
-#endif
+#include <string.h>             /* Need size_t.  */
 
 #ifndef __error_t_defined
 typedef int error_t;
@@ -36,62 +32,59 @@ typedef int error_t;
 
 /* Make a '\0' separated arg vector from a unix argv vector, returning it in
    ARGZ, and the total length in LEN.  If a memory allocation error occurs,
-   ENOMEM is returned, otherwise 0.  The result can be destroyed using free. */
+   ENOMEM is returned, otherwise 0.  The result can be destroyed using free.  
*/
 
-extern error_t argz_create (char *const __argv[], char **restrict __argz,
-                            size_t *restrict __len);
+extern error_t argz_create (char *const /*argv*/[], char **restrict /*argz*/,
+                            size_t *restrict /*len*/);
 
 /* Make a '\0' separated arg vector from a SEP separated list in
    STRING, returning it in ARGZ, and the total length in LEN.  If a
    memory allocation error occurs, ENOMEM is returned, otherwise 0.
    The result can be destroyed using free.  */
 
-extern error_t argz_create_sep (const char *restrict string,
-                                int __sep, char **restrict __argz,
-                                size_t *restrict __len);
+extern error_t argz_create_sep (const char *restrict /*string*/,
+                                int /*sep*/, char **restrict /*argz*/,
+                                size_t *restrict /*len*/);
 
 /* Returns the number of strings in ARGZ.  */
 
-extern size_t argz_count (const char *__argz, size_t __len)
-;
+extern size_t argz_count (const char */*argz*/, size_t /*len*/);
 
 /* Puts pointers to each string in ARGZ into ARGV, which must be large enough
    to hold them all.  */
 
-extern void argz_extract (const char *restrict __argz, size_t __len,
-                          char **restrict __argv);
+extern void argz_extract (const char *restrict /*argz*/, size_t /*len*/,
+                          char **restrict /*argv*/);
 
 /* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
    except the last into the character SEP.  */
 
-extern void argz_stringify (char *__argz, size_t __len, int __sep);
+extern void argz_stringify (char */*argz*/, size_t /*len*/, int /*sep*/);
 
 /* Append BUF, of length BUF_LEN to the argz vector in ARGZ & ARGZ_LEN.  */
 
-extern error_t argz_append (char **restrict __argz,
-                            size_t *restrict __argz_len,
-                            const char *restrict __buf, size_t __buf_len)
-;
+extern error_t argz_append (char **restrict /*argz*/,
+                            size_t *restrict /*argz_len*/,
+                            const char *restrict /*buf*/, size_t /*buf_len*/);
 
 /* Append STR to the argz vector in ARGZ & ARGZ_LEN.  */
 
-extern error_t argz_add (char **restrict __argz,
-                         size_t *restrict __argz_len,
+extern error_t argz_add (char **restrict /*argz*/,
+                         size_t *restrict /*argz_len*/,
                          const char *restrict str);
 
 /* Append SEP separated list in STRING to the argz vector in ARGZ &
    ARGZ_LEN.  */
 
-extern error_t argz_add_sep (char **restrict __argz,
-                             size_t *restrict __argz_len,
-                             const char *restrict string, int __delim)
-;
+extern error_t argz_add_sep (char **restrict /*argz*/,
+                             size_t *restrict /*argz_len*/,
+                             const char *restrict /*string*/, int /*delim*/);
 
 /* Delete ENTRY from ARGZ & ARGZ_LEN, if it appears there.  */
 
-extern void argz_delete (char **restrict __argz,
-                         size_t *restrict __argz_len,
-                         char *restrict __entry);
+extern void argz_delete (char **restrict /*argz*/,
+                         size_t *restrict /*argz_len*/,
+                         char *restrict /*entry*/);
 
 /* Insert ENTRY into ARGZ & ARGZ_LEN before BEFORE, which should be an
    existing entry in ARGZ; if BEFORE is NULL, ENTRY is appended to the end.
@@ -100,20 +93,20 @@ extern void argz_delete (char **restrict __argz,
    in ARGZ, EINVAL is returned, else if memory can't be allocated for the new
    ARGZ, ENOMEM is returned, else 0.  */
 
-extern error_t argz_insert (char **restrict __argz,
-                            size_t *restrict __argz_len,
-                            char *restrict __before,
-                            const char *restrict __entry);
+extern error_t argz_insert (char **restrict /*argz*/,
+                            size_t *restrict /*argz_len*/,
+                            char *restrict /*before*/,
+                            const char *restrict /*entry*/);
 
 /* Replace any occurrences of the string STR in ARGZ with WITH, reallocating
    ARGZ as necessary.  If REPLACE_COUNT is non-zero, *REPLACE_COUNT will be
    incremented by number of replacements performed.  */
 
-extern error_t argz_replace (char **restrict __argz,
-                             size_t *restrict __argz_len,
-                             const char *restrict str,
-                             const char *restrict __with,
-                             unsigned int *restrict __replace_count);
+extern error_t argz_replace (char **restrict /*argz*/,
+                             size_t *restrict /*argz_len*/,
+                             const char *restrict /*str*/,
+                             const char *restrict /*with*/,
+                             unsigned int *restrict /*replace_count*/);
 
 /* Returns the next entry in ARGZ & ARGZ_LEN after ENTRY, or NULL if there
    are no more.  If entry is NULL, then the first entry is returned.  This
@@ -130,31 +123,8 @@ extern error_t argz_replace (char **restrict __argz,
       ...;
 */
 
-extern char *argz_next (const char *restrict __argz, size_t __argz_len,
-                        const char *restrict __entry);
-
-#ifdef __USE_EXTERN_INLINES
-__extern_inline char *
-__NTH (argz_next (const char *__argz, size_t __argz_len,
-                    const char *__entry))
-{
-  if (__entry)
-    {
-      if (__entry < __argz + __argz_len)
-        __entry = strchr (__entry, '\0') + 1;
-
-      return __entry >= __argz + __argz_len ? (char *) NULL : (char *) __entry;
-    }
-  else
-    return __argz_len > 0 ? (char *) __argz : 0;
-}
-__extern_inline char *
-__NTH (argz_next (const char *__argz, size_t __argz_len,
-                  const char *__entry))
-{
-  return argz_next (__argz, __argz_len, __entry);
-}
-#endif /* Use extern inlines.  */
+extern char *argz_next (const char *restrict /*argz*/, size_t /*argz_len*/,
+                        const char *restrict /*entry*/);
 
 
 #endif /* argz.h */