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., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /*
  23
  24 NAME
  25
  26         concat -- concatenate a variable number of strings
  27
  28 SYNOPSIS
  29
  30         #include <varargs.h>
  31
  32         char *concat (s1, s2, s3, ..., NULL)
  33
  34 DESCRIPTION
  35
  36         Concatenate a variable number of strings and return the result
  37         in freshly malloc'd memory.
  38
  39         Returns NULL if insufficient memory is available.  The argument
  40         list is terminated by the first NULL pointer encountered.  Pointers
  41         to empty strings are ignored.
  42
  43 NOTES
  44
  45         This function uses xmalloc() which is expected to be a front end
  46         function to malloc() that deals with low memory situations.  In
  47         typical use, if malloc() returns NULL then xmalloc() diverts to an
  48         error handler routine which never returns, and thus xmalloc will
  49         never return a NULL pointer.  If the client application wishes to
  50         deal with low memory situations itself, it should supply an xmalloc
  51         that just directly invokes malloc and blindly returns whatever
  52         malloc returns.
  53 */
  54
  55
  56 #ifdef HAVE_CONFIG_H
  57 #include "config.h"
  58 #endif
  59 #include "ansidecl.h"
  60 #include "libiberty.h"
  61 #include <sys/types.h>          /* size_t */
  62
  63 #ifdef ANSI_PROTOTYPES
  64 #include <stdarg.h>
  65 #else
  66 #include <varargs.h>
  67 #endif
  68
  69 # if HAVE_STRING_H
  70 #  include <string.h>
  71 # else
  72 #  if HAVE_STRINGS_H
  73 #   include <strings.h>
  74 #  endif
  75 # endif
  76
  77 static inline unsigned long vconcat_length PARAMS ((const char *, va_list));
  78 static inline unsigned long
  79 vconcat_length (first, args)
  80      const char *first;
  81      va_list args;
  82 {
  83   unsigned long length = 0;
  84   const char *arg;
  85
  86   for (arg = first; arg ; arg = va_arg (args, const char *))
  87     length += strlen (arg);
  88
  89   return length;
  90 }
  91
  92 static inline char *vconcat_copy PARAMS ((char *, const char *, va_list));
  93 static inline char *
  94 vconcat_copy (dst, first, args)
  95      char *dst;
  96      const char *first;
  97      va_list args;
  98 {
  99   char *end = dst;
 100   const char *arg;
 101
 102   for (arg = first; arg ; arg = va_arg (args, const char *))
 103     {
 104       unsigned long length = strlen (arg);
 105       memcpy (end, arg, length);
 106       end += length;
 107     }
 108   *end = '\000';
 109
 110   return dst;
 111 }
 112
 113 unsigned long
 114 concat_length VPARAMS ((const char *first, ...))
 115 {
 116   unsigned long length;
 117
 118   VA_OPEN (args, first);
 119   VA_FIXEDARG (args, const char *, first);
 120   length = vconcat_length (first, args);
 121   VA_CLOSE (args);
 122
 123   return length;
 124 }
 125
 126 char *
 127 concat_copy VPARAMS ((char *dst, const char *first, ...))
 128 {
 129   char *save_dst;
 130
 131   VA_OPEN (args, first);
 132   VA_FIXEDARG (args, char *, dst);
 133   VA_FIXEDARG (args, const char *, first);
 134   vconcat_copy (dst, first, args);
 135   save_dst = dst; /* With K&R C, dst goes out of scope here.  */
 136   VA_CLOSE (args);
 137
 138   return save_dst;
 139 }
 140
 141 char *libiberty_concat_ptr;
 142
 143 char *
 144 concat_copy2 VPARAMS ((const char *first, ...))
 145 {
 146   VA_OPEN (args, first);
 147   VA_FIXEDARG (args, const char *, first);
 148   vconcat_copy (libiberty_concat_ptr, first, args);
 149   VA_CLOSE (args);
 150
 151   return libiberty_concat_ptr;
 152 }
 153
 154 char *
 155 concat VPARAMS ((const char *first, ...))
 156 {
 157   char *newstr;
 158
 159   /* First compute the size of the result and get sufficient memory.  */
 160   VA_OPEN (args, first);
 161   VA_FIXEDARG (args, const char *, first);
 162   newstr = (char *) xmalloc (vconcat_length (first, args) + 1);
 163   VA_CLOSE (args);
 164
 165   /* Now copy the individual pieces to the result string. */
 166   VA_OPEN (args, first);
 167   VA_FIXEDARG (args, const char *, first);
 168   vconcat_copy (newstr, first, args);
 169   VA_CLOSE (args);
 170
 171   return newstr;
 172 }
 173
 174 char *
 175 reconcat VPARAMS ((char *optr, const char *first, ...))
 176 {
 177   char *newstr;
 178
 179   /* First compute the size of the result and get sufficient memory.  */
 180   VA_OPEN (args, first);
 181   VA_FIXEDARG (args, char *, optr);
 182   VA_FIXEDARG (args, const char *, first);
 183   newstr = (char *) xmalloc (vconcat_length (first, args) + 1);
 184   VA_CLOSE (args);
 185
 186   /* Now copy the individual pieces to the result string. */
 187   VA_OPEN (args, first);
 188   VA_FIXEDARG (args, char *, optr);
 189   VA_FIXEDARG (args, const char *, first);
 190   vconcat_copy (newstr, first, args);
 191   VA_CLOSE (args);
 192
 193   if (optr)
 194     free (optr);
 195
 196   return newstr;
 197 }
 198
 199 #ifdef MAIN
 200 #define NULLP (char *)0
 201
 202 /* Simple little test driver. */
 203
 204 #include <stdio.h>
 205
 206 int
 207 main ()
 208 {
 209   printf ("\"\" = \"%s\"\n", concat (NULLP));
 210   printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
 211   printf ("\"ab\" = \"%s\"\n", concat ("a", "b", NULLP));
 212   printf ("\"abc\" = \"%s\"\n", concat ("a", "b", "c", NULLP));
 213   printf ("\"abcd\" = \"%s\"\n", concat ("ab", "cd", NULLP));
 214   printf ("\"abcde\" = \"%s\"\n", concat ("ab", "c", "de", NULLP));
 215   printf ("\"abcdef\" = \"%s\"\n", concat ("", "a", "", "bcd", "ef", NULLP));
 216   return 0;
 217 }
 218
 219 #endif