lib/libc/stdio/xprintf_str.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2005 Poul-Henning Kamp
   5  * Copyright (c) 1990, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Chris Torek.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $FreeBSD$
  36  */
  37
  38 #include <namespace.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <limits.h>
  43 #include <stdint.h>
  44 #include <assert.h>
  45 #include <wchar.h>
  46 #include "printf.h"
  47
  48 /*
  49  * Convert a wide character string argument for the %ls format to a multibyte
  50  * string representation. If not -1, prec specifies the maximum number of
  51  * bytes to output, and also means that we can't assume that the wide char.
  52  * string ends is null-terminated.
  53  */
  54 static char *
  55 __wcsconv(wchar_t *wcsarg, int prec)
  56 {
  57         static const mbstate_t initial;
  58         mbstate_t mbs;
  59         char buf[MB_LEN_MAX];
  60         wchar_t *p;
  61         char *convbuf;
  62         size_t clen, nbytes;
  63
  64         /* Allocate space for the maximum number of bytes we could output. */
  65         if (prec < 0) {
  66                 p = wcsarg;
  67                 mbs = initial;
  68                 nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs);
  69                 if (nbytes == (size_t)-1)
  70                         return (NULL);
  71         } else {
  72                 /*
  73                  * Optimisation: if the output precision is small enough,
  74                  * just allocate enough memory for the maximum instead of
  75                  * scanning the string.
  76                  */
  77                 if (prec < 128)
  78                         nbytes = prec;
  79                 else {
  80                         nbytes = 0;
  81                         p = wcsarg;
  82                         mbs = initial;
  83                         for (;;) {
  84                                 clen = wcrtomb(buf, *p++, &mbs);
  85                                 if (clen == 0 || clen == (size_t)-1 ||
  86                                     (int)(nbytes + clen) > prec)
  87                                         break;
  88                                 nbytes += clen;
  89                         }
  90                 }
  91         }
  92         if ((convbuf = malloc(nbytes + 1)) == NULL)
  93                 return (NULL);
  94
  95         /* Fill the output buffer. */
  96         p = wcsarg;
  97         mbs = initial;
  98         if ((nbytes = wcsrtombs(convbuf, (const wchar_t **)&p,
  99             nbytes, &mbs)) == (size_t)-1) {
 100                 free(convbuf);
 101                 return (NULL);
 102         }
 103         convbuf[nbytes] = '\0';
 104         return (convbuf);
 105 }
 106
 107
 108 /* 's' ---------------------------------------------------------------*/
 109
 110 int
 111 __printf_arginfo_str(const struct printf_info *pi, size_t n, int *argt)
 112 {
 113
 114         assert (n > 0);
 115         if (pi->is_long || pi->spec == 'C')
 116                 argt[0] = PA_WSTRING;
 117         else
 118                 argt[0] = PA_STRING;
 119         return (1);
 120 }
 121
 122 int
 123 __printf_render_str(struct __printf_io *io, const struct printf_info *pi, const void *const *arg)
 124 {
 125         const char *p;
 126         wchar_t *wcp;
 127         char *convbuf;
 128         int l;
 129
 130         if (pi->is_long || pi->spec == 'S') {
 131                 wcp = *((wint_t **)arg[0]);
 132                 if (wcp == NULL)
 133                         return (__printf_out(io, pi, "(null)", 6));
 134                 convbuf = __wcsconv(wcp, pi->prec);
 135                 if (convbuf == NULL)
 136                         return (-1);
 137                 l = __printf_out(io, pi, convbuf, strlen(convbuf));
 138                 free(convbuf);
 139                 return (l);
 140         }
 141         p = *((char **)arg[0]);
 142         if (p == NULL)
 143                 return (__printf_out(io, pi, "(null)", 6));
 144         l = strlen(p);
 145         if (pi->prec >= 0 && pi->prec < l)
 146                 l = pi->prec;
 147         return (__printf_out(io, pi, p, l));
 148 }
 149
 150 /* 'c' ---------------------------------------------------------------*/
 151
 152 int
 153 __printf_arginfo_chr(const struct printf_info *pi, size_t n, int *argt)
 154 {
 155
 156         assert (n > 0);
 157         if (pi->is_long || pi->spec == 'C')
 158                 argt[0] = PA_WCHAR;
 159         else
 160                 argt[0] = PA_INT;
 161         return (1);
 162 }
 163
 164 int
 165 __printf_render_chr(struct __printf_io *io, const struct printf_info *pi, const void *const *arg)
 166 {
 167         int i;
 168         wint_t ii;
 169         unsigned char c;
 170         static const mbstate_t initial;         /* XXX: this is bogus! */
 171         mbstate_t mbs;
 172         size_t mbseqlen;
 173         char buf[MB_CUR_MAX];
 174
 175         if (pi->is_long || pi->spec == 'C') {
 176                 ii = *((wint_t *)arg[0]);
 177
 178                 mbs = initial;
 179                 mbseqlen = wcrtomb(buf, (wchar_t)ii, &mbs);
 180                 if (mbseqlen == (size_t) -1)
 181                         return (-1);
 182                 return (__printf_out(io, pi, buf, mbseqlen));
 183         }
 184         i = *((int *)arg[0]);
 185         c = i;
 186         i = __printf_out(io, pi, &c, 1);
 187         __printf_flush(io);
 188         return (i);
 189 }