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