Return to concat.c CVS log

Up to [Apple XNU] / GNUtools / debug / gdb / libiberty

Annotation of GNUtools/debug/gdb/libiberty/concat.c, revision 1.1.1.1

1.1       root        1: /* Concatenate variable number of strings.
                      2:    Copyright (C) 1991 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., 675 Mass Ave,
                     19: Cambridge, MA 02139, 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: #include <varargs.h>
                     57: 
                     58: #define NULLP (char *)0
                     59: 
                     60: #ifdef NeXT
                     61: #define xmalloc(l) malloc(l)
                     62: extern char *malloc ();
                     63: #else
                     64: extern char *xmalloc ();
                     65: #endif /* NeXT */
                     66: 
                     67: /* VARARGS */
                     68: char *
                     69: concat (va_alist)
                     70:      va_dcl
                     71: {
                     72:   register int length = 0;
                     73:   register char *newstr;
                     74:   register char *end;
                     75:   register char *arg;
                     76:   va_list args;
                     77: 
                     78:   /* First compute the size of the result and get sufficient memory. */
                     79: 
                     80:   va_start (args);
                     81:   while ((arg = va_arg (args, char *)) != NULLP)
                     82:     {
                     83:       length += strlen (arg);
                     84:     }
                     85:   newstr = (char *) xmalloc (length + 1);
                     86:   va_end (args);
                     87: 
                     88:   /* Now copy the individual pieces to the result string. */
                     89: 
                     90:   if (newstr != NULLP)
                     91:     {
                     92:       va_start (args);
                     93:       end = newstr;
                     94:       while ((arg = va_arg (args, char *)) != NULLP)
                     95:        {
                     96:          while (*arg)
                     97:            {
                     98:              *end++ = *arg++;
                     99:            }
                    100:        }
                    101:       *end = '\000';
                    102:       va_end (args);
                    103:     }
                    104: 
                    105:   return (newstr);
                    106: }
                    107: 
                    108: #ifdef MAIN
                    109: 
                    110: /* Simple little test driver. */
                    111: 
                    112: main ()
                    113: {
                    114:   printf ("\"\" = \"%s\"\n", concat (NULLP));
                    115:   printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
                    116:   printf ("\"ab\" = \"%s\"\n", concat ("a", "b", NULLP));
                    117:   printf ("\"abc\" = \"%s\"\n", concat ("a", "b", "c", NULLP));
                    118:   printf ("\"abcd\" = \"%s\"\n", concat ("ab", "cd", NULLP));
                    119:   printf ("\"abcde\" = \"%s\"\n", concat ("ab", "c", "de", NULLP));
                    120:   printf ("\"abcdef\" = \"%s\"\n", concat ("", "a", "", "bcd", "ef", NULLP));
                    121: }
                    122: 
                    123: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.