merge from gcc
[external/binutils.git] / 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 @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 char *libiberty_concat_ptr;
131
132 /* @undocumented concat_copy2 */
133
134 char *
135 concat_copy2 (const char *first, ...)
136 {
137   VA_OPEN (args, first);
138   VA_FIXEDARG (args, const char *, first);
139   vconcat_copy (libiberty_concat_ptr, first, args);
140   VA_CLOSE (args);
141
142   return libiberty_concat_ptr;
143 }
144
145 char *
146 concat (const char *first, ...)
147 {
148   char *newstr;
149
150   /* First compute the size of the result and get sufficient memory.  */
151   VA_OPEN (args, first);
152   VA_FIXEDARG (args, const char *, first);
153   newstr = (char *) xmalloc (vconcat_length (first, args) + 1);
154   VA_CLOSE (args);
155
156   /* Now copy the individual pieces to the result string. */
157   VA_OPEN (args, first);
158   VA_FIXEDARG (args, const char *, first);
159   vconcat_copy (newstr, first, args);
160   VA_CLOSE (args);
161
162   return newstr;
163 }
164
165 /*
166
167 @deftypefn Extension char* reconcat (char *@var{optr}, const char *@var{s1}, @dots{}, @code{NULL})
168
169 Same as @code{concat}, except that if @var{optr} is not @code{NULL} it
170 is freed after the string is created.  This is intended to be useful
171 when you're extending an existing string or building up a string in a
172 loop:
173
174 @example
175   str = reconcat (str, "pre-", str, NULL);
176 @end example
177
178 @end deftypefn
179
180 */
181
182 char *
183 reconcat (char *optr, const char *first, ...)
184 {
185   char *newstr;
186
187   /* First compute the size of the result and get sufficient memory.  */
188   VA_OPEN (args, first);
189   VA_FIXEDARG (args, char *, optr);
190   VA_FIXEDARG (args, const char *, first);
191   newstr = (char *) xmalloc (vconcat_length (first, args) + 1);
192   VA_CLOSE (args);
193
194   /* Now copy the individual pieces to the result string. */
195   VA_OPEN (args, first);
196   VA_FIXEDARG (args, char *, optr);
197   VA_FIXEDARG (args, const char *, first);
198   vconcat_copy (newstr, first, args);
199   if (optr) /* Done before VA_CLOSE so optr stays in scope for K&R C.  */
200     free (optr);
201   VA_CLOSE (args);
202
203   return newstr;
204 }
205
206 #ifdef MAIN
207 #define NULLP (char *)0
208
209 /* Simple little test driver. */
210
211 #include <stdio.h>
212
213 int
214 main (void)
215 {
216   printf ("\"\" = \"%s\"\n", concat (NULLP));
217   printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
218   printf ("\"ab\" = \"%s\"\n", concat ("a", "b", NULLP));
219   printf ("\"abc\" = \"%s\"\n", concat ("a", "b", "c", NULLP));
220   printf ("\"abcd\" = \"%s\"\n", concat ("ab", "cd", NULLP));
221   printf ("\"abcde\" = \"%s\"\n", concat ("ab", "c", "de", NULLP));
222   printf ("\"abcdef\" = \"%s\"\n", concat ("", "a", "", "bcd", "ef", NULLP));
223   return 0;
224 }
225
226 #endif