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 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