OSDN Git Service

85c17e930eef7f6ad9f38324b14a605f6cace923
[pf3gnuchains/gcc-fork.git] / libiberty / argv.c
1 /* Create and destroy argument vectors (argv's)
2    Copyright (C) 1992 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 /*  Create and destroy argument vectors.  An argument vector is simply an
23     array of string pointers, terminated by a NULL pointer. */
24
25 #include "ansidecl.h"
26 #include "libiberty.h"
27
28 #ifdef isspace
29 #undef isspace
30 #endif
31 #define isspace(ch) ((ch) == ' ' || (ch) == '\t')
32
33 /*  Routines imported from standard C runtime libraries. */
34
35 #ifdef __STDC__
36
37 #include <stddef.h>
38 extern void *memcpy (void *s1, const void *s2, size_t n);       /* 4.11.2.1 */
39 extern size_t strlen (const char *s);                           /* 4.11.6.3 */
40 extern void *malloc (size_t size);                              /* 4.10.3.3 */
41 extern void *realloc (void *ptr, size_t size);                  /* 4.10.3.4 */
42 extern void free (void *ptr);                                   /* 4.10.3.2 */
43 extern char *strdup (const char *s);                            /* Non-ANSI */
44
45 #else   /* !__STDC__ */
46
47 #if !defined _WIN32 || defined __GNUC__
48 extern char *memcpy ();         /* Copy memory region */
49 extern int strlen ();           /* Count length of string */
50 extern char *malloc ();         /* Standard memory allocater */
51 extern char *realloc ();        /* Standard memory reallocator */
52 extern void free ();            /* Free malloc'd memory */
53 extern char *strdup ();         /* Duplicate a string */
54 #endif
55
56 #endif  /* __STDC__ */
57
58 #include "alloca-conf.h"
59
60 #ifndef NULL
61 #define NULL 0
62 #endif
63
64 #ifndef EOS
65 #define EOS '\0'
66 #endif
67
68 #define INITIAL_MAXARGC 8       /* Number of args + NULL in initial argv */
69
70
71 /*
72
73 NAME
74
75         dupargv -- duplicate an argument vector
76
77 SYNOPSIS
78
79         char **dupargv (vector)
80         char **vector;
81
82 DESCRIPTION
83
84         Duplicate an argument vector.  Simply scans through the
85         vector, duplicating each argument until the
86         terminating NULL is found.
87
88 RETURNS
89
90         Returns a pointer to the argument vector if
91         successful. Returns NULL if there is insufficient memory to
92         complete building the argument vector.
93
94 */
95
96 char **
97 dupargv (argv)
98      char **argv;
99 {
100   int argc;
101   char **copy;
102   
103   if (argv == NULL)
104     return NULL;
105   
106   /* the vector */
107   for (argc = 0; argv[argc] != NULL; argc++);
108   copy = (char **) malloc ((argc + 1) * sizeof (char *));
109   if (copy == NULL)
110     return NULL;
111   
112   /* the strings */
113   for (argc = 0; argv[argc] != NULL; argc++)
114     {
115       int len = strlen (argv[argc]);
116       copy[argc] = malloc (sizeof (char *) * (len + 1));
117       if (copy[argc] == NULL)
118         {
119           freeargv (copy);
120           return NULL;
121         }
122       strcpy (copy[argc], argv[argc]);
123     }
124   copy[argc] = NULL;
125   return copy;
126 }
127
128 /*
129
130 NAME
131
132         freeargv -- free an argument vector
133
134 SYNOPSIS
135
136         void freeargv (vector)
137         char **vector;
138
139 DESCRIPTION
140
141         Free an argument vector that was built using buildargv.  Simply scans
142         through the vector, freeing the memory for each argument until the
143         terminating NULL is found, and then frees the vector itself.
144
145 RETURNS
146
147         No value.
148
149 */
150
151 void freeargv (vector)
152 char **vector;
153 {
154   register char **scan;
155
156   if (vector != NULL)
157     {
158       for (scan = vector; *scan != NULL; scan++)
159         {
160           free (*scan);
161         }
162       free (vector);
163     }
164 }
165
166 /*
167
168 NAME
169
170         buildargv -- build an argument vector from a string
171
172 SYNOPSIS
173
174         char **buildargv (sp)
175         char *sp;
176
177 DESCRIPTION
178
179         Given a pointer to a string, parse the string extracting fields
180         separated by whitespace and optionally enclosed within either single
181         or double quotes (which are stripped off), and build a vector of
182         pointers to copies of the string for each field.  The input string
183         remains unchanged.
184
185         All of the memory for the pointer array and copies of the string
186         is obtained from malloc.  All of the memory can be returned to the
187         system with the single function call freeargv, which takes the
188         returned result of buildargv, as it's argument.
189
190         The memory for the argv array is dynamically expanded as necessary.
191
192 RETURNS
193
194         Returns a pointer to the argument vector if successful. Returns NULL
195         if the input string pointer is NULL or if there is insufficient
196         memory to complete building the argument vector.
197
198 NOTES
199
200         In order to provide a working buffer for extracting arguments into,
201         with appropriate stripping of quotes and translation of backslash
202         sequences, we allocate a working buffer at least as long as the input
203         string.  This ensures that we always have enough space in which to
204         work, since the extracted arg is never larger than the input string.
205
206         If the input is a null string (as opposed to a NULL pointer), then
207         buildarg returns an argv that has one arg, a null string.
208
209         Argv is always kept terminated with a NULL arg pointer, so it can
210         be passed to freeargv at any time, or returned, as appropriate.
211 */
212
213 char **buildargv (input)
214 char *input;
215 {
216   char *arg;
217   char *copybuf;
218   int squote = 0;
219   int dquote = 0;
220   int bsquote = 0;
221   int argc = 0;
222   int maxargc = 0;
223   char **argv = NULL;
224   char **nargv;
225
226   if (input != NULL)
227     {
228       copybuf = (char *) alloca (strlen (input) + 1);
229       /* Is a do{}while to always execute the loop once.  Always return an
230          argv, even for null strings.  See NOTES above, test case below. */
231       do
232         {
233           /* Pick off argv[argc] */
234           while (isspace (*input))
235             {
236               input++;
237             }
238           if ((maxargc == 0) || (argc >= (maxargc - 1)))
239             {
240               /* argv needs initialization, or expansion */
241               if (argv == NULL)
242                 {
243                   maxargc = INITIAL_MAXARGC;
244                   nargv = (char **) malloc (maxargc * sizeof (char *));
245                 }
246               else
247                 {
248                   maxargc *= 2;
249                   nargv = (char **) realloc (argv, maxargc * sizeof (char *));
250                 }
251               if (nargv == NULL)
252                 {
253                   if (argv != NULL)
254                     {
255                       freeargv (argv);
256                       argv = NULL;
257                     }
258                   break;
259                 }
260               argv = nargv;
261               argv[argc] = NULL;
262             }
263           /* Begin scanning arg */
264           arg = copybuf;
265           while (*input != EOS)
266             {
267               if (isspace (*input) && !squote && !dquote && !bsquote)
268                 {
269                   break;
270                 }
271               else
272                 {
273                   if (bsquote)
274                     {
275                       bsquote = 0;
276                       *arg++ = *input;
277                     }
278                   else if (*input == '\\')
279                     {
280                       bsquote = 1;
281                     }
282                   else if (squote)
283                     {
284                       if (*input == '\'')
285                         {
286                           squote = 0;
287                         }
288                       else
289                         {
290                           *arg++ = *input;
291                         }
292                     }
293                   else if (dquote)
294                     {
295                       if (*input == '"')
296                         {
297                           dquote = 0;
298                         }
299                       else
300                         {
301                           *arg++ = *input;
302                         }
303                     }
304                   else
305                     {
306                       if (*input == '\'')
307                         {
308                           squote = 1;
309                         }
310                       else if (*input == '"')
311                         {
312                           dquote = 1;
313                         }
314                       else
315                         {
316                           *arg++ = *input;
317                         }
318                     }
319                   input++;
320                 }
321             }
322           *arg = EOS;
323           argv[argc] = strdup (copybuf);
324           if (argv[argc] == NULL)
325             {
326               freeargv (argv);
327               argv = NULL;
328               break;
329             }
330           argc++;
331           argv[argc] = NULL;
332
333           while (isspace (*input))
334             {
335               input++;
336             }
337         }
338       while (*input != EOS);
339     }
340   return (argv);
341 }
342
343 #ifdef MAIN
344
345 /* Simple little test driver. */
346
347 static char *tests[] =
348 {
349   "a simple command line",
350   "arg 'foo' is single quoted",
351   "arg \"bar\" is double quoted",
352   "arg \"foo bar\" has embedded whitespace",
353   "arg 'Jack said \\'hi\\'' has single quotes",
354   "arg 'Jack said \\\"hi\\\"' has double quotes",
355   "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9",
356   
357   /* This should be expanded into only one argument.  */
358   "trailing-whitespace ",
359
360   "",
361   NULL
362 };
363
364 main ()
365 {
366   char **argv;
367   char **test;
368   char **targs;
369
370   for (test = tests; *test != NULL; test++)
371     {
372       printf ("buildargv(\"%s\")\n", *test);
373       if ((argv = buildargv (*test)) == NULL)
374         {
375           printf ("failed!\n\n");
376         }
377       else
378         {
379           for (targs = argv; *targs != NULL; targs++)
380             {
381               printf ("\t\"%s\"\n", *targs);
382             }
383           printf ("\n");
384         }
385       freeargv (argv);
386     }
387
388 }
389
390 #endif  /* MAIN */