libiberty/concat.c

   1 /* Concatenate variable number of strings.
   2    Copyright (C) 1991, 1994, 2001, 2011 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}, @
  25   @dots{}, @code{NULL})
  26
  27 Concatenate zero or more of strings and return the result in freshly
  28 @code{xmalloc}ed memory.  The argument list is terminated by the first
  29 @code{NULL} pointer encountered.  Pointers to empty strings are ignored.
  30
  31 @end deftypefn
  32
  33 */
  34
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39 #include "ansidecl.h"
  40 #include "libiberty.h"
  41 #include <sys/types.h>          /* size_t */
  42
  43 #include <stdarg.h>
  44
  45 # if HAVE_STRING_H
  46 #  include <string.h>
  47 # else
  48 #  if HAVE_STRINGS_H
  49 #   include <strings.h>
  50 #  endif
  51 # endif
  52
  53 #if HAVE_STDLIB_H
  54 #include <stdlib.h>
  55 #endif
  56
  57 static inline unsigned long vconcat_length (const char *, va_list);
  58 static inline unsigned long
  59 vconcat_length (const char *first, va_list args)
  60 {
  61   unsigned long length = 0;
  62   const char *arg;
  63
  64   for (arg = first; arg ; arg = va_arg (args, const char *))
  65     length += strlen (arg);
  66
  67   return length;
  68 }
  69
  70 static inline char *
  71 vconcat_copy (char *dst, const char *first, va_list args)
  72 {
  73   char *end = dst;
  74   const char *arg;
  75
  76   for (arg = first; arg ; arg = va_arg (args, const char *))
  77     {
  78       unsigned long length = strlen (arg);
  79       memcpy (end, arg, length);
  80       end += length;
  81     }
  82   *end = '\000';
  83
  84   return dst;
  85 }
  86
  87 /* @undocumented concat_length */
  88
  89 unsigned long
  90 concat_length (const char *first, ...)
  91 {
  92   unsigned long length;
  93
  94   VA_OPEN (args, first);
  95   VA_FIXEDARG (args, const char *, first);
  96   length = vconcat_length (first, args);
  97   VA_CLOSE (args);
  98
  99   return length;
 100 }
 101
 102 /* @undocumented concat_copy */
 103
 104 char *
 105 concat_copy (char *dst, const char *first, ...)
 106 {
 107   char *save_dst;
 108
 109   VA_OPEN (args, first);
 110   VA_FIXEDARG (args, char *, dst);
 111   VA_FIXEDARG (args, const char *, first);
 112   vconcat_copy (dst, first, args);
 113   save_dst = dst; /* With K&R C, dst goes out of scope here.  */
 114   VA_CLOSE (args);
 115
 116   return save_dst;
 117 }
 118
 119 #ifdef __cplusplus
 120 extern "C" {
 121 #endif /* __cplusplus */
 122 char *libiberty_concat_ptr;
 123 #ifdef __cplusplus
 124 }
 125 #endif /* __cplusplus */
 126
 127 /* @undocumented concat_copy2 */
 128
 129 char *
 130 concat_copy2 (const char *first, ...)
 131 {
 132   VA_OPEN (args, first);
 133   VA_FIXEDARG (args, const char *, first);
 134   vconcat_copy (libiberty_concat_ptr, first, args);
 135   VA_CLOSE (args);
 136
 137   return libiberty_concat_ptr;
 138 }
 139
 140 char *
 141 concat (const char *first, ...)
 142 {
 143   char *newstr;
 144
 145   /* First compute the size of the result and get sufficient memory.  */
 146   VA_OPEN (args, first);
 147   VA_FIXEDARG (args, const char *, first);
 148   newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
 149   VA_CLOSE (args);
 150
 151   /* Now copy the individual pieces to the result string. */
 152   VA_OPEN (args, first);
 153   VA_FIXEDARG (args, const char *, first);
 154   vconcat_copy (newstr, first, args);
 155   VA_CLOSE (args);
 156
 157   return newstr;
 158 }
 159
 160 /*
 161
 162 @deftypefn Extension char* reconcat (char *@var{optr}, const char *@var{s1}, @
 163   @dots{}, @code{NULL})
 164
 165 Same as @code{concat}, except that if @var{optr} is not @code{NULL} it
 166 is freed after the string is created.  This is intended to be useful
 167 when you're extending an existing string or building up a string in a
 168 loop:
 169
 170 @example
 171   str = reconcat (str, "pre-", str, NULL);
 172 @end example
 173
 174 @end deftypefn
 175
 176 */
 177
 178 char *
 179 reconcat (char *optr, const char *first, ...)
 180 {
 181   char *newstr;
 182
 183   /* First compute the size of the result and get sufficient memory.  */
 184   VA_OPEN (args, first);
 185   VA_FIXEDARG (args, char *, optr);
 186   VA_FIXEDARG (args, const char *, first);
 187   newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
 188   VA_CLOSE (args);
 189
 190   /* Now copy the individual pieces to the result string. */
 191   VA_OPEN (args, first);
 192   VA_FIXEDARG (args, char *, optr);
 193   VA_FIXEDARG (args, const char *, first);
 194   vconcat_copy (newstr, first, args);
 195   if (optr) /* Done before VA_CLOSE so optr stays in scope for K&R C.  */
 196     free (optr);
 197   VA_CLOSE (args);
 198
 199   return newstr;
 200 }
 201
 202 #ifdef MAIN
 203 #define NULLP (char *)0
 204
 205 /* Simple little test driver. */
 206
 207 #include <stdio.h>
 208
 209 int
 210 main (void)
 211 {
 212   printf ("\"\" = \"%s\"\n", concat (NULLP));
 213   printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
 214   printf ("\"ab\" = \"%s\"\n", concat ("a", "b", NULLP));
 215   printf ("\"abc\" = \"%s\"\n", concat ("a", "b", "c", NULLP));
 216   printf ("\"abcd\" = \"%s\"\n", concat ("ab", "cd", NULLP));
 217   printf ("\"abcde\" = \"%s\"\n", concat ("ab", "c", "de", NULLP));
 218   printf ("\"abcdef\" = \"%s\"\n", concat ("", "a", "", "bcd", "ef", NULLP));
 219   return 0;
 220 }
 221
 222 #endif