| 1 | 
         207 | 
         jeremybenn | 
         /*
  | 
      
      
         | 2 | 
          | 
          | 
         FUNCTION
  | 
      
      
         | 3 | 
          | 
          | 
                 <<wcsncat>>---concatenate part of two wide-character strings
  | 
      
      
         | 4 | 
          | 
          | 
          
  | 
      
      
         | 5 | 
          | 
          | 
         ANSI_SYNOPSIS
  | 
      
      
         | 6 | 
          | 
          | 
                 #include <wchar.h>
  | 
      
      
         | 7 | 
          | 
          | 
                 wchar_t *wcsncat(wchar_t *<[s1]>, const wchar_t *<[s2]>, size_t <[n]>);
  | 
      
      
         | 8 | 
          | 
          | 
          
  | 
      
      
         | 9 | 
          | 
          | 
         TRAD_SYNOPSIS
  | 
      
      
         | 10 | 
          | 
          | 
                 wchar_t *wcsncat(<[s1]>, <[s2]>, <[n]>
  | 
      
      
         | 11 | 
          | 
          | 
                 wchar_t *<[s1]>;
  | 
      
      
         | 12 | 
          | 
          | 
                 const wchar_t *<[s2]>;
  | 
      
      
         | 13 | 
          | 
          | 
                 size_t <[n]>;
  | 
      
      
         | 14 | 
          | 
          | 
          
  | 
      
      
         | 15 | 
          | 
          | 
         DESCRIPTION
  | 
      
      
         | 16 | 
          | 
          | 
                 The <<wcsncat>> function appends not more than <[n]> wide-character
  | 
      
      
         | 17 | 
          | 
          | 
                 codes (a null wide-character code and wide-character codes that follow
  | 
      
      
         | 18 | 
          | 
          | 
                 it are not appended) from the array pointed to by <[s2]> to the end of
  | 
      
      
         | 19 | 
          | 
          | 
                 the wide-character string pointed to by <[s1]>. The initial
  | 
      
      
         | 20 | 
          | 
          | 
                 wide-character code of <[s2]> overwrites the null wide-character code
  | 
      
      
         | 21 | 
          | 
          | 
                 at the end of <[s1]>.
  | 
      
      
         | 22 | 
          | 
          | 
                 A terminating null wide-character code is always appended to the result.
  | 
      
      
         | 23 | 
          | 
          | 
                 If copying takes place between objects that overlap, the behaviour is
  | 
      
      
         | 24 | 
          | 
          | 
                 undefined.
  | 
      
      
         | 25 | 
          | 
          | 
          
  | 
      
      
         | 26 | 
          | 
          | 
         RETURNS
  | 
      
      
         | 27 | 
          | 
          | 
                 The <<wcsncat>> function returns <[s1]>; no return value is reserved to
  | 
      
      
         | 28 | 
          | 
          | 
                 indicate an error.
  | 
      
      
         | 29 | 
          | 
          | 
          
  | 
      
      
         | 30 | 
          | 
          | 
         PORTABILITY
  | 
      
      
         | 31 | 
          | 
          | 
         <<wcsncat>> is ISO/IEC 9899/AMD1:1995 (ISO C).
  | 
      
      
         | 32 | 
          | 
          | 
          
  | 
      
      
         | 33 | 
          | 
          | 
         No supporting OS subroutines are required.
  | 
      
      
         | 34 | 
          | 
          | 
         */
  | 
      
      
         | 35 | 
          | 
          | 
          
  | 
      
      
         | 36 | 
          | 
          | 
         /*      $NetBSD: wcsncat.c,v 1.1 2000/12/23 23:14:36 itojun Exp $       */
  | 
      
      
         | 37 | 
          | 
          | 
          
  | 
      
      
         | 38 | 
          | 
          | 
         /*-
  | 
      
      
         | 39 | 
          | 
          | 
          * Copyright (c)1999 Citrus Project,
  | 
      
      
         | 40 | 
          | 
          | 
          * All rights reserved.
  | 
      
      
         | 41 | 
          | 
          | 
          *
  | 
      
      
         | 42 | 
          | 
          | 
          * Redistribution and use in source and binary forms, with or without
  | 
      
      
         | 43 | 
          | 
          | 
          * modification, are permitted provided that the following conditions
  | 
      
      
         | 44 | 
          | 
          | 
          * are met:
  | 
      
      
         | 45 | 
          | 
          | 
          * 1. Redistributions of source code must retain the above copyright
  | 
      
      
         | 46 | 
          | 
          | 
          *    notice, this list of conditions and the following disclaimer.
  | 
      
      
         | 47 | 
          | 
          | 
          * 2. Redistributions in binary form must reproduce the above copyright
  | 
      
      
         | 48 | 
          | 
          | 
          *    notice, this list of conditions and the following disclaimer in the
  | 
      
      
         | 49 | 
          | 
          | 
          *    documentation and/or other materials provided with the distribution.
  | 
      
      
         | 50 | 
          | 
          | 
          *
  | 
      
      
         | 51 | 
          | 
          | 
          * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  | 
      
      
         | 52 | 
          | 
          | 
          * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  | 
      
      
         | 53 | 
          | 
          | 
          * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  | 
      
      
         | 54 | 
          | 
          | 
          * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  | 
      
      
         | 55 | 
          | 
          | 
          * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  | 
      
      
         | 56 | 
          | 
          | 
          * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  | 
      
      
         | 57 | 
          | 
          | 
          * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  | 
      
      
         | 58 | 
          | 
          | 
          * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  | 
      
      
         | 59 | 
          | 
          | 
          * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  | 
      
      
         | 60 | 
          | 
          | 
          * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  | 
      
      
         | 61 | 
          | 
          | 
          * SUCH DAMAGE.
  | 
      
      
         | 62 | 
          | 
          | 
          *
  | 
      
      
         | 63 | 
          | 
          | 
          *      citrus Id: wcsncat.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
  | 
      
      
         | 64 | 
          | 
          | 
          */
  | 
      
      
         | 65 | 
          | 
          | 
          
  | 
      
      
         | 66 | 
          | 
          | 
         #include <_ansi.h>
  | 
      
      
         | 67 | 
          | 
          | 
         #include <wchar.h>
  | 
      
      
         | 68 | 
          | 
          | 
          
  | 
      
      
         | 69 | 
          | 
          | 
         wchar_t *
  | 
      
      
         | 70 | 
          | 
          | 
         _DEFUN (wcsncat, (s1, s2, n),
  | 
      
      
         | 71 | 
          | 
          | 
                 wchar_t * s1 _AND
  | 
      
      
         | 72 | 
          | 
          | 
                 _CONST wchar_t * s2 _AND
  | 
      
      
         | 73 | 
          | 
          | 
                 size_t n)
  | 
      
      
         | 74 | 
          | 
          | 
         {
  | 
      
      
         | 75 | 
          | 
          | 
           wchar_t *p;
  | 
      
      
         | 76 | 
          | 
          | 
           wchar_t *q;
  | 
      
      
         | 77 | 
          | 
          | 
           _CONST wchar_t *r;
  | 
      
      
         | 78 | 
          | 
          | 
          
  | 
      
      
         | 79 | 
          | 
          | 
           p = s1;
  | 
      
      
         | 80 | 
          | 
          | 
           while (*p)
  | 
      
      
         | 81 | 
          | 
          | 
             p++;
  | 
      
      
         | 82 | 
          | 
          | 
           q = p;
  | 
      
      
         | 83 | 
          | 
          | 
           r = s2;
  | 
      
      
         | 84 | 
          | 
          | 
           while (*r && n)
  | 
      
      
         | 85 | 
          | 
          | 
             {
  | 
      
      
         | 86 | 
          | 
          | 
               *q++ = *r++;
  | 
      
      
         | 87 | 
          | 
          | 
               n--;
  | 
      
      
         | 88 | 
          | 
          | 
             }
  | 
      
      
         | 89 | 
          | 
          | 
           *q = '\0';
  | 
      
      
         | 90 | 
          | 
          | 
           return s1;
  | 
      
      
         | 91 | 
          | 
          | 
         }
  |