libiberty/concat.c

   1 /* Concatenate variable number of strings.
   2    Copyright (C) 1991, 1994, 2001 Free Software Foundation, Inc.
   3    Written by Fred Fish @ Cygnus Support
   4
   5 This file is part of the libiberty library.
   6 Libiberty is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at your option) any later version.
  10
  11 Libiberty is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with libiberty; see the file COPYING.LIB.  If
  18 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  19 Boston, MA 02110-1301, USA.  */
  20
  21
  22 /*
  23
  24 @deftypefn Extension char* concat (const char *@var{s1}, const char *@var{s2}, @dots{}, @code{NULL})
  25
  26 Concatenate zero or more of strings and return the result in freshly
  27 @code{xmalloc}ed memory.  Returns @code{NULL} if insufficient memory is
  28 available.  The argument list is terminated by the first @code{NULL}
  29 pointer encountered.  Pointers to empty strings are ignored.
  30
  31 @end deftypefn
  32
  33 NOTES
  34
  35         This function uses xmalloc() which is expected to be a front end
  36         function to malloc() that deals with low memory situations.  In
  37         typical use, if malloc() returns NULL then xmalloc() diverts to an
  38         error handler routine which never returns, and thus xmalloc will
  39         never return a NULL pointer.  If the client application wishes to
  40         deal with low memory situations itself, it should supply an xmalloc
  41         that just directly invokes malloc and blindly returns whatever
  42         malloc returns.
  43
  44 */
  45
  46
  47 #ifdef HAVE_CONFIG_H
  48 #include "config.h"
  49 #endif
  50 #include "ansidecl.h"
  51 #include "libiberty.h"
  52 #include <sys/types.h>          /* size_t */
  53
  54 #include <stdarg.h>
  55
  56 # if HAVE_STRING_H
  57 #  include <string.h>
  58 # else
  59 #  if HAVE_STRINGS_H
  60 #   include <strings.h>
  61 #  endif
  62 # endif
  63
  64 #if HAVE_STDLIB_H
  65 #include <stdlib.h>
  66 #endif
  67
  68 static inline unsigned long vconcat_length (const char *, va_list);
  69 static inline unsigned long
  70 vconcat_length (const char *first, va_list args)
  71 {
  72   unsigned long length = 0;
  73   const char *arg;
  74
  75   for (arg = first; arg ; arg = va_arg (args, const char *))
  76     length += strlen (arg);
  77
  78   return length;
  79 }
  80
  81 static inline char *
  82 vconcat_copy (char *dst, const char *first, va_list args)
  83 {
  84   char *end = dst;
  85   const char *arg;
  86
  87   for (arg = first; arg ; arg = va_arg (args, const char *))
  88     {
  89       unsigned long length = strlen (arg);
  90       memcpy (end, arg, length);
  91       end += length;
  92     }
  93   *end = '\000';
  94
  95   return dst;
  96 }
  97
  98 /* @undocumented concat_length */
  99
 100 unsigned long
 101 concat_length (const char *first, ...)
 102 {
 103   unsigned long length;
 104
 105   VA_OPEN (args, first);
 106   VA_FIXEDARG (args, const char *, first);
 107   length = vconcat_length (first, args);
 108   VA_CLOSE (args);
 109
 110   return length;
 111 }
 112
 113 /* @undocumented concat_copy */
 114
 115 char *
 116 concat_copy (char *dst, const char *first, ...)
 117 {
 118   char *save_dst;
 119
 120   VA_OPEN (args, first);
 121   VA_FIXEDARG (args, char *, dst);
 122   VA_FIXEDARG (args, const char *, first);
 123   vconcat_copy (dst, first, args);
 124   save_dst = dst; /* With K&R C, dst goes out of scope here.  */
 125   VA_CLOSE (args);
 126
 127   return save_dst;
 128 }
 129
 130 #ifdef __cplusplus
 131 extern "C" {
 132 #endif /* __cplusplus */
 133 char *libiberty_concat_ptr;
 134 #ifdef __cplusplus
 135 }
 136 #endif /* __cplusplus */
 137
 138 /* @undocumented concat_copy2 */
 139
 140 char *
 141 concat_copy2 (const char *first, ...)
 142 {
 143   VA_OPEN (args, first);
 144   VA_FIXEDARG (args, const char *, first);
 145   vconcat_copy (libiberty_concat_ptr, first, args);
 146   VA_CLOSE (args);
 147
 148   return libiberty_concat_ptr;
 149 }
 150
 151 char *
 152 concat (const char *first, ...)
 153 {
 154   char *newstr;
 155
 156   /* First compute the size of the result and get sufficient memory.  */
 157   VA_OPEN (args, first);
 158   VA_FIXEDARG (args, const char *, first);
 159   newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
 160   VA_CLOSE (args);
 161
 162   /* Now copy the individual pieces to the result string. */
 163   VA_OPEN (args, first);
 164   VA_FIXEDARG (args, const char *, first);
 165   vconcat_copy (newstr, first, args);
 166   VA_CLOSE (args);
 167
 168   return newstr;
 169 }
 170
 171 /*
 172
 173 @deftypefn Extension char* reconcat (char *@var{optr}, const char *@var{s1}, @dots{}, @code{NULL})
 174
 175 Same as @code{concat}, except that if @var{optr} is not @code{NULL} it
 176 is freed after the string is created.  This is intended to be useful
 177 when you're extending an existing string or building up a string in a
 178 loop:
 179
 180 @example
 181   str = reconcat (str, "pre-", str, NULL);
 182 @end example
 183
 184 @end deftypefn
 185
 186 */
 187
 188 char *
 189 reconcat (char *optr, const char *first, ...)
 190 {
 191   char *newstr;
 192
 193   /* First compute the size of the result and get sufficient memory.  */
 194   VA_OPEN (args, first);
 195   VA_FIXEDARG (args, char *, optr);
 196   VA_FIXEDARG (args, const char *, first);
 197   newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
 198   VA_CLOSE (args);
 199
 200   /* Now copy the individual pieces to the result string. */
 201   VA_OPEN (args, first);
 202   VA_FIXEDARG (args, char *, optr);
 203   VA_FIXEDARG (args, const char *, first);
 204   vconcat_copy (newstr, first, args);
 205   if (optr) /* Done before VA_CLOSE so optr stays in scope for K&R C.  */
 206     free (optr);
 207   VA_CLOSE (args);
 208
 209   return newstr;
 210 }
 211
 212 #ifdef MAIN
 213 #define NULLP (char *)0
 214
 215 /* Simple little test driver. */
 216
 217 #include <stdio.h>
 218
 219 int
 220 main (void)
 221 {
 222   printf ("\"\" = \"%s\"\n", concat (NULLP));
 223   printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
 224   printf ("\"ab\" = \"%s\"\n", concat ("a", "b", NULLP));
 225   printf ("\"abc\" = \"%s\"\n", concat ("a", "b", "c", NULLP));
 226   printf ("\"abcd\" = \"%s\"\n", concat ("ab", "cd", NULLP));
 227   printf ("\"abcde\" = \"%s\"\n", concat ("ab", "c", "de", NULLP));
 228   printf ("\"abcdef\" = \"%s\"\n", concat ("", "a", "", "bcd", "ef", NULLP));
 229   return 0;
 230 }
 231
 232 #endif