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