Loading...
--- /dev/null
+++ Libc/Libc-1244.1.7/stdio/FreeBSD/xprintf.c
@@ -0,0 +1,1199 @@
+/*-
+ * Copyright (c) 2005 Poul-Henning Kamp
+ * Copyright (c) 1990, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libc/stdio/xprintf.c,v 1.9 2010/03/11 17:03:32 jhb Exp $
+ */
+
+#include "namespace.h"
+#include <err.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <stdint.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <namespace.h>
+#include <string.h>
+#include <wchar.h>
+#include <errno.h>
+#include "un-namespace.h"
+
+//#define MACHTIME
+#ifdef MACHTIME
+#include <mach/mach_time.h>
+#endif // MACHTIME
+
+#ifdef XPRINTF_PERF
+#include <libkern/OSAtomic.h>
+#endif /* XPRINTF_PERF */
+
+#include "local.h"
+#include "xprintf_private.h"
+#include "xprintf_domain.h"
+#include "fvwrite.h"
+
+/*
+ * Defining XPRINTF_DEBUG allows the __private_extern__ variable __use_xprintf
+ * to be set so that regular printf variants will use the extensible printf
+ * code path. This is normally off, and is only used to test the extensible
+ * printf code in the conformance tests.
+ */
+#ifdef XPRINTF_DEBUG
+#include <unistd.h>
+int __use_xprintf = 0;
+#endif
+
+/* private stuff -----------------------------------------------------*/
+
+union arg {
+ int intarg;
+ long longarg;
+ intmax_t intmaxarg;
+#ifndef NO_FLOATING_POINT
+ double doublearg;
+ long double longdoublearg;
+#endif
+ wint_t wintarg;
+ char *pchararg;
+ wchar_t *pwchararg;
+ void *pvoidarg;
+#ifdef VECTORS
+ VECTORTYPE vectorarg;
+ unsigned char vuchararg[16];
+ signed char vchararg[16];
+ unsigned short vushortarg[8];
+ signed short vshortarg[8];
+ unsigned int vuintarg[4];
+ signed int vintarg[4];
+ float vfloatarg[4];
+#ifdef V64TYPE
+ double vdoublearg[2];
+ unsigned long long vulonglongarg[2];
+ long long vlonglongarg[2];
+#endif /* V64TYPE */
+#endif /* VECTORS */
+};
+
+/*
+ * Macros for converting digits to letters and vice versa
+ */
+#define to_digit(c) ((c) - '0')
+#define is_digit(c) (((unsigned)to_digit(c)) <= 9)
+
+/* various globals ---------------------------------------------------*/
+
+__private_extern__ const char __lowercase_hex[17] = "0123456789abcdef?"; /*lint !e784 */
+__private_extern__ const char __uppercase_hex[17] = "0123456789ABCDEF?"; /*lint !e784 */
+
+#define PADSIZE 16
+static char blanks[PADSIZE] =
+ {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
+static char zeroes[PADSIZE] =
+ {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
+
+/* printing and padding functions ------------------------------------*/
+
+#define NIOV 8
+
+struct __printf_io {
+ FILE *fp;
+ struct __suio uio;
+ struct __siov iov[NIOV];
+ struct __siov *iovp;
+};
+
+static void
+__printf_init(struct __printf_io *io)
+{
+
+ io->uio.uio_iov = io->iovp = &io->iov[0];
+ io->uio.uio_resid = 0;
+ io->uio.uio_iovcnt = 0;
+}
+
+__private_extern__ void
+__printf_flush(struct __printf_io *io)
+{
+
+ __sfvwrite(io->fp, &io->uio);
+ __printf_init(io);
+}
+
+__private_extern__ int
+__printf_puts(struct __printf_io *io, const void *ptr, int len)
+{
+
+
+#if 0
+ if (io->fp->_flags & __SERR)
+ return (0);
+#endif
+ if (len == 0)
+ return (0);
+ io->iovp->iov_base = __DECONST(void *, ptr);
+ io->iovp->iov_len = len;
+ io->uio.uio_resid += len;
+ io->iovp++;
+ io->uio.uio_iovcnt++;
+ if (io->uio.uio_iovcnt >= NIOV)
+ __printf_flush(io);
+ return (len);
+}
+
+__private_extern__ int
+__printf_pad(struct __printf_io *io, int howmany, int zero)
+{
+ int n;
+ const char *with;
+ int ret = 0;
+
+ if (zero)
+ with = zeroes;
+ else
+ with = blanks;
+
+ if ((n = (howmany)) > 0) {
+ while (n > PADSIZE) {
+ ret += __printf_puts(io, with, PADSIZE);
+ n -= PADSIZE;
+ }
+ ret += __printf_puts(io, with, n);
+ }
+ return (ret);
+}
+
+__private_extern__ int
+__printf_out(struct __printf_io *io, const struct printf_info *pi, const void *ptr, int len)
+{
+ int ret = 0;
+
+ if ((!pi->left) && pi->width > len)
+ ret += __printf_pad(io, pi->width - len, pi->pad == '0');
+ ret += __printf_puts(io, ptr, len);
+ if (pi->left && pi->width > len)
+ ret += __printf_pad(io, pi->width - len, pi->pad == '0');
+ return (ret);
+}
+
+
+/* percent handling -------------------------------------------------*/
+
+__private_extern__ int
+__printf_arginfo_pct(const struct printf_info *pi __unused, size_t n __unused, int *argt __unused)
+{
+
+ return (0);
+}
+
+__private_extern__ int
+__printf_render_pct(struct __printf_io *io, const struct printf_info *pi __unused, const void *const *arg __unused)
+{
+
+ return (__printf_puts(io, "%", 1));
+}
+
+/* 'n' ---------------------------------------------------------------*/
+
+__private_extern__ int
+__printf_arginfo_n(const struct printf_info *pi, size_t n, int *argt)
+{
+
+ assert(n >= 1);
+ argt[0] = PA_POINTER;
+ return (1);
+}
+
+/*
+ * This is a printf_render so that all output has been flushed before it
+ * gets called.
+ */
+
+__private_extern__ int
+__printf_render_n(FILE *io __unused, const struct printf_info *pi, const void *const *arg)
+{
+
+ if (pi->is_char)
+ **((signed char **)arg[0]) = (signed char)pi->sofar;
+ else if (pi->is_short)
+ **((short **)arg[0]) = (short)pi->sofar;
+ else if (pi->is_long)
+ **((long **)arg[0]) = pi->sofar;
+ else if (pi->is_long_double)
+ **((long long **)arg[0]) = pi->sofar;
+ else if (pi->is_intmax)
+ **((intmax_t **)arg[0]) = pi->sofar;
+ else if (pi->is_ptrdiff)
+ **((ptrdiff_t **)arg[0]) = pi->sofar;
+ else if (pi->is_quad)
+ **((quad_t **)arg[0]) = pi->sofar;
+ else if (pi->is_size)
+ **((size_t **)arg[0]) = pi->sofar;
+ else
+ **((int **)arg[0]) = pi->sofar;
+
+ return (0);
+}
+
+/* dynamic array handling -------------------------------------------------*/
+#define ARRAYDELTA 8
+
+struct array {
+#ifdef XPRINTF_PERF
+ struct array *next;
+#endif /* XPRINTF_PERF */
+ void *data;
+ int itemsize;
+ int max;
+};
+
+#ifdef XPRINTF_PERF
+__private_extern__
+#else /* !XPRINTF_PERF */
+static
+#endif /* !XPRINTF_PERF */
+void
+arrayfree(struct array *a)
+{
+ if(a) free(a->data);
+}
+
+static void *
+arrayget(struct array *a, int i)
+{
+ if (i >= a->max) {
+ int oldsize = a->max * a->itemsize;
+ int newmax = i + ARRAYDELTA;
+ int newsize = newmax * a->itemsize;
+ void *newdata = realloc(a->data, newsize);
+ if(!newdata) return NULL;
+ bzero(newdata + oldsize, newsize - oldsize);
+ a->data = newdata;
+ a->max = newmax;
+ }
+ return a->data + i * a->itemsize;
+}
+
+static struct array *
+arrayinit(struct array *a, int itemsize)
+{
+ a->data = CALLOC(ARRAYDELTA, itemsize);
+ if(!a->data) return NULL;
+ a->itemsize = itemsize;
+ a->max = ARRAYDELTA;
+ return a;
+}
+
+/* dynamic array caching -------------------------------------------------*/
+/*
+ * Normally, dynamic array structures are created on the stack, and array
+ * itself is freshly allocated, and then freed when no longer needed. When
+ * the XPRINTF_PERF macro is defined, the dynamic array structures associated
+ * with all-in-one printf variants are not freed, but store in a cache for
+ * later use (dynamic array structures used for compile/execute continue to
+ * be freed after they are no longer needed). This means there should be
+ * at most one structure in the cached per thread that actually used the
+ * all-in-one printf variant.
+ *
+ * The amount of memory that is cached is fairly small, totally about 1K
+ * for three structures used by a format string using ten conversion
+ * specifiers. This is too small for purgeable memory.
+ *
+ * However, we do flush these caches in case we every are unable to allocate
+ * memory, and retry the allocation, just in case.
+ */
+#ifdef XPRINTF_PERF
+static OSQueueHead arg_type_queue = OS_ATOMIC_QUEUE_INIT;
+static OSQueueHead printf_info_queue = OS_ATOMIC_QUEUE_INIT;
+static OSQueueHead union_arg_queue = OS_ATOMIC_QUEUE_INIT;
+
+#define DEFINE_DEQUEUE(which, type) \
+static struct array * \
+which ## _dequeue(void) \
+{ \
+ struct array *a = (struct array *)OSAtomicDequeue(&which ## _queue, offsetof(struct array, next)); \
+ \
+ if (a) { \
+ bzero(a->data, a->max * a->itemsize); \
+ return a; \
+ } \
+ a = (struct array *)MALLOC(sizeof(*a)); \
+ if (!a) return NULL; \
+ if (!arrayinit(a, sizeof(type))) { \
+ free(a); \
+ return NULL; \
+ } \
+ return a; \
+}
+
+#define DEFINE_ENQUEUE(which) \
+__private_extern__ void \
+which ## _enqueue(struct array *a) \
+{ \
+ if (!a) return; \
+ OSAtomicEnqueue(&which ## _queue, a, offsetof(struct array, next)); \
+}
+
+#define DEFINE_FLUSH(which) \
+static void \
+which ## _flush(void) \
+{ \
+ struct array *a; \
+ while((a = (struct array *)OSAtomicDequeue(&which ## _queue, offsetof(struct array, next))) != NULL) { \
+ arrayfree(a); \
+ free(a); \
+ } \
+}
+
+DEFINE_DEQUEUE(arg_type, int)
+DEFINE_ENQUEUE(arg_type)
+DEFINE_FLUSH(arg_type)
+DEFINE_DEQUEUE(printf_info, struct printf_info)
+DEFINE_ENQUEUE(printf_info)
+DEFINE_FLUSH(printf_info)
+DEFINE_DEQUEUE(union_arg, union arg)
+DEFINE_ENQUEUE(union_arg)
+DEFINE_FLUSH(union_arg)
+
+static void
+flush_queues(void)
+{
+ arg_type_flush();
+ printf_info_flush();
+ union_arg_flush();
+}
+
+__private_extern__ void *
+xprintf_calloc(size_t count, size_t size)
+{
+ void *x = calloc(count, size);
+ if(!x) {
+ flush_queues();
+ x = calloc(count, size);
+ }
+ return x;
+}
+
+__private_extern__ void *
+xprintf_malloc(size_t size)
+{
+ void *x = malloc(size);
+ if(!x) {
+ flush_queues();
+ x = malloc(size);
+ }
+ return x;
+}
+
+#if 0
+void
+show_queues(void)
+{
+ struct array *a;
+ printf("arg_type:");
+ while((a = (struct array *)OSAtomicDequeue(&arg_type_queue, offsetof(struct array, next))) != NULL) printf("\n%p", a);
+ printf("\nprintf_info:");
+ while((a = (struct array *)OSAtomicDequeue(&printf_info_queue, offsetof(struct array, next))) != NULL) printf("\n%p", a);
+ printf("\nunion_arg:");
+ while((a = (struct array *)OSAtomicDequeue(&union_arg_queue, offsetof(struct array, next))) != NULL) printf("\n%p", a);
+ printf("\n");
+}
+#endif
+#endif /* XPRINTF_PERF */
+
+/* -------------------------------------------------------------------------*/
+
+__private_extern__ int
+__printf_comp(printf_comp_t restrict pc, printf_domain_t restrict domain)
+{
+ struct printf_info *pi, *pil;
+ const char *fmt;
+ int ch, pii;
+ int *argt;
+ int nextarg;
+ int maxarg;
+ int ret = 0;
+ int n;
+#ifndef XPRINTF_PERF
+ struct array piarr, argtarr;
+#endif /* XPRINTF_PERF */
+ struct array *pa, *aa;
+
+ fmt = pc->fmt;
+ maxarg = 0;
+ nextarg = 1;
+#ifdef XPRINTF_PERF
+ pa = printf_info_dequeue();
+#else /* !XPRINTF_PERF */
+ pa = arrayinit(&piarr, sizeof(*pi));
+#endif /* !XPRINTF_PERF */
+ if (!pa) {
+#ifdef XPRINTF_PERF
+ flush_queues();
+#endif /* XPRINTF_PERF */
+ return EOF;
+ }
+#ifdef XPRINTF_PERF
+ pc->pa = pa;
+ aa = arg_type_dequeue();
+#else /* !XPRINTF_PERF */
+ aa = arrayinit(&argtarr, sizeof(*argt));
+#endif /* !XPRINTF_PERF */
+ if (!aa) {
+ arrayfree(pa);
+#ifdef XPRINTF_PERF
+ free(pa);
+ flush_queues();
+#endif /* XPRINTF_PERF */
+ return EOF;
+ }
+#ifdef XPRINTF_PERF
+ pc->aa = aa;
+#endif /* XPRINTF_PERF */
+ for (pii = 0; ; pii++) {
+ pi = arrayget(pa, pii);
+ if (!pi) {
+ ret = EOF;
+ goto error;
+ }
+ pil = pi;
+ if (*fmt == '\0')
+ break;
+ pil = pi + 1;
+ pi->prec = -1;
+ pi->pad = ' ';
+#ifdef VECTORS
+ pi->vsep = 'X'; /* Illegal value, changed to defaults later. */
+#endif /* VECTORS */
+ pi->begin = pi->end = fmt;
+ while (*fmt != '\0' && *fmt != '%')
+ pi->end = ++fmt;
+ if (*fmt == '\0')
+ break;
+ fmt++;
+ for (;;) {
+ pi->spec = *fmt;
+ switch (pi->spec) {
+ case ' ':
+ /*-
+ * ``If the space and + flags both appear, the space
+ * flag will be ignored.''
+ * -- ANSI X3J11
+ */
+ if (pi->showsign == 0) {
+ pi->space = 1;
+ pi->signchar = ' ';
+ }
+ fmt++;
+ continue;
+ case '#':
+ pi->alt = 1;
+ fmt++;
+ continue;
+#ifdef VECTORS
+ case ',': case ';': case ':': case '_':
+ pi->vsep = pi->spec;
+ fmt++;
+ continue;
+#endif /* VECTORS */
+ case '.':
+ pi->prec = 0;
+ fmt++;
+ if (*fmt == '*') {
+ fmt++;
+ /* Look for *nn$ and deal with it */
+ n = 0;
+ while (*fmt != '\0' && is_digit(*fmt)) {
+ n *= 10;
+ n += to_digit(*fmt);
+ fmt++;
+ }
+ if (*fmt == '$') {
+ if ((n + 1) > maxarg)
+ maxarg = (n + 1);
+ fmt++;
+ } else n = nextarg++;
+ pi->get_prec = n;
+ argt = (int *)arrayget(aa, n);
+ if (!argt) {
+ ret = EOF;
+ goto error;
+ }
+ *argt = PA_INT;
+ continue;
+ }
+ while (*fmt != '\0' && is_digit(*fmt)) {
+ pi->prec *= 10;
+ pi->prec += to_digit(*fmt);
+ fmt++;
+ }
+ continue;
+ case '-':
+ pi->left = 1;
+ fmt++;
+ continue;
+ case '+':
+ pi->showsign = 1;
+ pi->signchar = '+';
+ fmt++;
+ continue;
+ case '*':
+ fmt++;
+ /* Look for *nn$ and deal with it */
+ n = 0;
+ while (*fmt != '\0' && is_digit(*fmt)) {
+ n *= 10;
+ n += to_digit(*fmt);
+ fmt++;
+ }
+ if (*fmt == '$') {
+ if ((n + 1) > maxarg)
+ maxarg = (n + 1);
+ fmt++;
+ } else n = nextarg++;
+ pi->get_width = n;
+ argt = (int *)arrayget(aa, n);
+ if (!argt) {
+ ret = EOF;
+ goto error;
+ }
+ *argt = PA_INT;
+ continue;
+ case '%':
+ fmt++;
+ break;
+ case '\'':
+ pi->group = 1;
+ fmt++;
+ continue;
+ case '0':
+ /*-
+ * ``Note that 0 is taken as a flag, not as the
+ * beginning of a field width.''
+ * -- ANSI X3J11
+ */
+ pi->pad = '0';
+ fmt++;
+ continue;
+ case '1': case '2': case '3':
+ case '4': case '5': case '6':
+ case '7': case '8': case '9':
+ n = 0;
+ while (*fmt != '\0' && is_digit(*fmt)) {
+ n *= 10;
+ n += to_digit(*fmt);
+ fmt++;
+ }
+ if (*fmt == '$') {
+ if (nextarg > maxarg)
+ maxarg = nextarg;
+ nextarg = n;
+ fmt++;
+ } else
+ pi->width = n;
+ continue;
+#if 0
+ case 'D':
+ case 'O':
+ case 'U':
+ pi->spec += ('a' - 'A');
+ pi->is_intmax = 0;
+ if (pi->is_long_double || pi->is_quad) {
+ pi->is_long = 0;
+ pi->is_long_double = 1;
+ } else {
+ pi->is_long = 1;
+ pi->is_long_double = 0;
+ }
+ fmt++;
+ break;
+#endif
+ case 'j':
+ pi->is_intmax = 1;
+ fmt++;
+ continue;
+ case 'q':
+ pi->is_long = 0;
+ pi->is_quad = 1;
+ fmt++;
+ continue;
+ case 'L':
+ pi->is_long_double = 1;
+ fmt++;
+ continue;
+ case 'h':
+ fmt++;
+ if (*fmt == 'h') {
+ fmt++;
+ pi->is_char = 1;
+ } else {
+ pi->is_short = 1;
+ }
+ continue;
+ case 'l':
+ fmt++;
+ if (*fmt == 'l') {
+ fmt++;
+ pi->is_long_double = 1;
+ pi->is_quad = 0;
+ } else {
+ pi->is_quad = 0;
+ pi->is_long = 1;
+ }
+ continue;
+ case 't':
+ pi->is_ptrdiff = 1;
+ fmt++;
+ continue;
+ case 'v':
+#ifdef VECTORS
+ pi->is_vec = 1;
+#endif /* VECTORS */
+ fmt++;
+ continue;
+ case 'z':
+ pi->is_size = 1;
+ fmt++;
+ continue;
+ default:
+ fmt++;
+ break;
+ }
+ if (printf_tbl_in_range(pi->spec)) {
+ switch(domain->type[printf_tbl_index(pi->spec)]) {
+ /* ignore PRINTF_DOMAIN_UNUSED until later */
+ case PRINTF_DOMAIN_FLAG:
+ errx(1, "Unexpected flag: %c", pi->spec);
+ case PRINTF_DOMAIN_GLIBC_API:
+ case PRINTF_DOMAIN_FBSD_API:
+ /*
+ * Insure that there are always
+ * __PRINTFMAXARG available.
+ */
+ if (!arrayget(aa, nextarg + __PRINTFMAXARG - 1)) {
+ ret = EOF;
+ goto error;
+ }
+ pi->context = domain->tbl[printf_tbl_index(pi->spec)].context;
+ pi->loc = pc->loc;
+ ch = domain->tbl[printf_tbl_index(pi->spec)].arginfo(
+ pi, __PRINTFMAXARG, arrayget(aa, nextarg));
+ if (ch > 0)
+ pi->arg[0] = (void *)(long)nextarg;
+ if (ch > 1)
+ pi->arg[1] = (void *)(long)(nextarg + 1);
+ nextarg += ch;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ if (nextarg > maxarg)
+ maxarg = nextarg;
+ pc->argt = aa->data;
+ pc->pi = pa->data;
+ pc->pil = pil;
+ pc->maxarg = ch = maxarg;
+ if (ch < 1) ch = 1;
+#ifdef XPRINTF_PERF
+ pc->ua = union_arg_dequeue();
+ if (!pc->ua) {
+ ret = EOF;
+ goto error;
+ }
+ if (!arrayget(pc->ua, ch)) {
+ union_arg_enqueue(pc->ua);
+ ret = EOF;
+ goto error;
+ }
+ pc->args = pc->ua->data;
+#else /* !XPRINTF_PERF */
+ pc->args = (union arg *)malloc(ch * sizeof(*pc->args));
+ if (!pc->args) {
+ ret = EOF;
+ goto error;
+ }
+#endif /* !XPRINTF_PERF */
+ for (pi = pc->pi; pi < pil; pi++) {
+ if (pi->arg[0]) pi->arg[0] = &pc->args[(long)pi->arg[0]];
+ if (pi->arg[1]) pi->arg[1] = &pc->args[(long)pi->arg[1]];
+ }
+#if 0
+ fprintf(stderr, "fmt0 <%s>\n", fmt0);
+ fprintf(stderr, "pil %p\n", pil);
+#endif
+ pc->domain = domain;
+
+ return (ret);
+error:
+ arrayfree(pa);
+ arrayfree(aa);
+#ifdef XPRINTF_PERF
+ free(pa);
+ free(aa);
+ flush_queues();
+#endif /* XPRINTF_PERF */
+ return (ret);
+}
+
+__private_extern__ int
+__printf_exec(printf_comp_t restrict pc, FILE * restrict fp, va_list ap)
+{
+ struct printf_info *pi;
+ int ch;
+ int ret = 0;
+ int n;
+ struct __printf_io io;
+
+ __printf_init(&io);
+ io.fp = fp;
+
+ for (ch = 1; ch < pc->maxarg; ch++) {
+#if 0
+ fprintf(stderr, "arg %d %x\n", ch, pc->argt[ch]);
+#endif
+ switch(pc->argt[ch]) {
+ case PA_CHAR:
+ pc->args[ch].intarg = (char)va_arg (ap, int);
+ break;
+ case PA_INT:
+ pc->args[ch].intarg = va_arg (ap, int);
+ break;
+ case PA_INT | PA_FLAG_SHORT:
+ pc->args[ch].intarg = (short)va_arg (ap, int);
+ break;
+ case PA_INT | PA_FLAG_LONG:
+ pc->args[ch].longarg = va_arg (ap, long);
+ break;
+ case PA_INT | PA_FLAG_INTMAX:
+ pc->args[ch].intmaxarg = va_arg (ap, intmax_t);
+ break;
+ case PA_INT | PA_FLAG_QUAD:
+ pc->args[ch].intmaxarg = va_arg (ap, quad_t);
+ break;
+ case PA_INT | PA_FLAG_LONG_LONG:
+ pc->args[ch].intmaxarg = va_arg (ap, long long);
+ break;
+ case PA_INT | PA_FLAG_SIZE:
+ pc->args[ch].intmaxarg = va_arg (ap, size_t);
+ break;
+ case PA_INT | PA_FLAG_PTRDIFF:
+ pc->args[ch].intmaxarg = (unsigned long)va_arg (ap, ptrdiff_t);
+ break;
+ case PA_WCHAR:
+ pc->args[ch].wintarg = va_arg (ap, wint_t);
+ break;
+ case PA_POINTER:
+ pc->args[ch].pvoidarg = va_arg (ap, void *);
+ break;
+ case PA_STRING:
+ pc->args[ch].pchararg = va_arg (ap, char *);
+ break;
+ case PA_WSTRING:
+ pc->args[ch].pwchararg = va_arg (ap, wchar_t *);
+ break;
+ case PA_DOUBLE:
+#ifndef NO_FLOATING_POINT
+ pc->args[ch].doublearg = va_arg (ap, double);
+#endif
+ break;
+ case PA_DOUBLE | PA_FLAG_LONG_DOUBLE:
+#ifndef NO_FLOATING_POINT
+ pc->args[ch].longdoublearg = va_arg (ap, long double);
+#endif
+ break;
+#ifdef VECTORS
+ case PA_VECTOR:
+ pc->args[ch].vectorarg = va_arg (ap, VECTORTYPE);
+ break;
+#endif /* VECTORS */
+ default:
+ errx(1, "argtype = %x (fmt = \"%s\")\n",
+ pc->argt[ch], pc->fmt);
+ }
+ }
+ for (pi = pc->pi; pi < pc->pil; pi++) {
+#if 0
+ fprintf(stderr, "pi %p", pi);
+ fprintf(stderr, " spec '%c'", pi->spec);
+ fprintf(stderr, " args %d",
+ ((uintptr_t)pi->arg[0] - (uintptr_t)pc->args) / sizeof pc->args[0]);
+ if (pi->width) fprintf(stderr, " width %d", pi->width);
+ if (pi->pad) fprintf(stderr, " pad 0x%x", pi->pad);
+ if (pi->left) fprintf(stderr, " left");
+ if (pi->showsign) fprintf(stderr, " showsign");
+ if (pi->signchar) fprintf(stderr, " signchar 0x%x", pi->signchar);
+ if (pi->prec != -1) fprintf(stderr, " prec %d", pi->prec);
+ if (pi->is_char) fprintf(stderr, " char");
+ if (pi->is_short) fprintf(stderr, " short");
+ if (pi->is_long) fprintf(stderr, " long");
+ if (pi->is_long_double) fprintf(stderr, " long_double");
+ fprintf(stderr, "\n");
+ fprintf(stderr, "\t\"%.*s\"\n", pi->end - pi->begin, pi->begin);
+#endif
+ if (pi->get_width) {
+ pi->width = pc->args[pi->get_width].intarg;
+ /*-
+ * ``A negative field width argument is taken as a
+ * - flag followed by a positive field width.''
+ * -- ANSI X3J11
+ * They don't exclude field widths read from args.
+ */
+ if (pi->width < 0) {
+ pi->left = 1;
+ pi->width = -pi->width;
+ }
+ }
+ if (pi->get_prec)
+ pi->prec = pc->args[pi->get_prec].intarg;
+ ret += __printf_puts(&io, pi->begin, pi->end - pi->begin);
+ if (pi->spec) {
+ if (!printf_tbl_in_range(pi->spec)) goto unused;
+ switch(pc->domain->type[printf_tbl_index(pi->spec)]) {
+ case PRINTF_DOMAIN_UNUSED:
+ unused:
+ {
+ char unknown = pi->spec;
+ ret += __printf_out(&io, pi, &unknown, 1);
+ break;
+ }
+ case PRINTF_DOMAIN_GLIBC_API:
+ __printf_flush(&io);
+ pi->sofar = ret;
+ ret += ((printf_function *)pc->domain->tbl[printf_tbl_index(pi->spec)].render)(
+ fp, pi, (const void *)pi->arg);
+ break;
+ case PRINTF_DOMAIN_FBSD_API:
+ pi->sofar = ret;
+ n = ((printf_render *)pc->domain->tbl[printf_tbl_index(pi->spec)].render)(
+ &io, pi, (const void *)pi->arg);
+ if (n < 0)
+ io.fp->_flags |= __SERR;
+ else
+ ret += n;
+ break;
+ }
+ }
+ }
+ __printf_flush(&io);
+ return (ret);
+}
+
+__private_extern__ int
+__v2printf(printf_comp_t restrict pc, printf_domain_t restrict domain, FILE * restrict fp, locale_t restrict loc, const char * restrict fmt, va_list ap)
+{
+ struct _printf_compiled spc;
+ int ret, saverrno;
+
+ /*
+ * All the printf family (including extensible printf variants) funnel
+ * down to this point. So we can do common work here, and then fork
+ * out to the appropriate handler.
+ */
+ /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
+ if (prepwrite(fp) != 0) {
+ errno = EBADF;
+ return (EOF);
+ }
+ ORIENT(fp, -1);
+
+ if (pc == XPRINTF_PLAIN) {
+ NORMALIZE_LOCALE(loc);
+#ifdef XPRINTF_DEBUG
+ if (!__use_xprintf)
+#endif
+ return __vfprintf(fp, loc, fmt, ap);
+#ifdef XPRINTF_DEBUG
+ xprintf_domain_init();
+ domain = xprintf_domain_global;
+#endif
+ } else if (pc) {
+ pthread_mutex_lock(&pc->mutex);
+ pthread_rwlock_rdlock(&pc->domain->rwlock);
+ ret = __printf_exec(pc, fp, ap);
+ saverrno = errno;
+ pthread_rwlock_unlock(&pc->domain->rwlock);
+ pthread_mutex_unlock(&pc->mutex);
+ errno = saverrno;
+ return ret;
+ }
+ if (!domain) {
+ errno = EINVAL;
+ return EOF;
+ }
+ xprintf_domain_init();
+ bzero(&spc, sizeof(spc));
+ spc.fmt = fmt;
+ DEFAULT_CURRENT_LOCALE(loc);
+ XL_RETAIN(loc);
+ spc.loc = loc;
+ /*
+ * We don't need to lock the printf_comp_t mutex, since the
+ * printf_comp_t was just created on the stack, and is private.
+ */
+ pthread_rwlock_rdlock(&domain->rwlock);
+ if (__printf_comp(&spc, domain) < 0) {
+ saverrno = errno;
+ pthread_rwlock_unlock(&domain->rwlock);
+ XL_RELEASE(loc);
+ errno = saverrno;
+ return EOF;
+ }
+ ret = __printf_exec(&spc, fp, ap);
+ saverrno = errno;
+ pthread_rwlock_unlock(&domain->rwlock);
+ XL_RELEASE(loc);
+
+#ifdef XPRINTF_PERF
+ printf_info_enqueue(spc.pa);
+ arg_type_enqueue(spc.aa);
+ union_arg_enqueue(spc.ua);
+#else /* !XPRINTF_PERF */
+ free(spc.pi);
+ free(spc.argt);
+ free(spc.args);
+#endif /* !XPRINTF_PERF */
+ errno = saverrno;
+ return ret;
+}
+
+extern int __fflush(FILE *fp);
+
+/*
+ * Helper function for `fprintf to unbuffered unix file': creates a
+ * temporary buffer. We only work on write-only files; this avoids
+ * worries about ungetc buffers and so forth.
+ */
+static int
+__v3printf(printf_comp_t restrict pc, printf_domain_t restrict domain, FILE * restrict fp, locale_t restrict loc, const char * restrict fmt, va_list ap)
+{
+ int ret;
+ FILE fake;
+ struct __sFILEX extra;
+ unsigned char buf[BUFSIZ];
+
+ fake._extra = &extra;
+ INITEXTRA(&fake);
+
+ /* copy the important variables */
+ fake._flags = fp->_flags & ~__SNBF;
+ fake._file = fp->_file;
+ fake._cookie = fp->_cookie;
+ fake._write = fp->_write;
+ fake._orientation = fp->_orientation;
+ fake._mbstate = fp->_mbstate;
+
+ /* set up the buffer */
+ fake._bf._base = fake._p = buf;
+ fake._bf._size = fake._w = sizeof(buf);
+ fake._lbfsize = 0; /* not actually used, but Just In Case */
+
+ /* do the work, then copy any error status */
+ ret = __v2printf(pc, domain, &fake, loc, fmt, ap);
+ if (ret >= 0 && __fflush(&fake))
+ ret = EOF;
+ if (fake._flags & __SERR)
+ fp->_flags |= __SERR;
+ return (ret);
+}
+
+__private_extern__ int
+__xvprintf(printf_comp_t restrict pc, printf_domain_t restrict domain, FILE * restrict fp, locale_t restrict loc, const char * restrict fmt0, va_list ap)
+{
+ int ret;
+
+ /* optimise fprintf(stderr) (and other unbuffered Unix files) */
+ if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
+ fp->_file >= 0)
+ ret = __v3printf(pc, domain, fp, loc, fmt0, ap);
+ else
+ ret = __v2printf(pc, domain, fp, loc, fmt0, ap);
+ return ret;
+}
+
+/* extending ---------------------------------------------------------*/
+
+// No global domain support
+#if 0
+int
+register_printf_function(int spec, printf_function *render, printf_arginfo_function *arginfo)
+{
+ return register_printf_domain_function(NULL, spec, render, arginfo);
+}
+
+__private_extern__ int
+register_printf_render(int spec, printf_render *render, printf_arginfo_function *arginfo)
+{
+ return register_printf_domain_render(NULL, spec, render, arginfo);
+}
+
+int
+register_printf_render_std(const char *specs)
+{
+ return register_printf_domain_render_std(NULL, specs);
+}
+#endif
+
+#ifdef VECTORS
+/* vector support ----------------------------------------------------*/
+
+#define PRINTVECTOR(_io, _pi, _arg, _cnt, _type, _elem, _render, _ret) { \
+ int i; \
+ _type a, *ap; \
+ a = (_type)(_arg)->_elem[0]; \
+ ap = &a; \
+ (_ret) += _render((_io), (_pi), (const void *)&ap); \
+ for(i = 1; i < (_cnt); i++) { \
+ (_ret) += __printf_puts((_io), (_pi)->begin, (_pi)->end - (_pi)->begin); \
+ a = (_type)(_arg)->_elem[i]; \
+ (_ret) += _render((_io), (_pi), (const void *)&ap); \
+ } \
+}
+
+#define PRINTVECTOR_P(_io, _pi, _arg, _cnt, _elem, _render, _ret) { \
+ int i; \
+ void * a, *ap; \
+ a = (void *)(uintptr_t)(_arg)->_elem[0]; \
+ ap = &a; \
+ (_ret) += _render((_io), (_pi), (const void *)&ap); \
+ for(i = 1; i < (_cnt); i++) { \
+ (_ret) += __printf_puts((_io), (_pi)->begin, (_pi)->end - (_pi)->begin); \
+ a = (void *)(uintptr_t)(_arg)->_elem[i]; \
+ (_ret) += _render((_io), (_pi), (const void *)&ap); \
+ } \
+}
+
+__private_extern__ int
+__xprintf_vector(struct __printf_io *io, const struct printf_info *pi, const void *const *arg)
+{
+ char vsep; /* Vector separator character. */
+ const union arg *argp;
+ int ret = 0;
+ struct printf_info info = *pi;
+
+ argp = arg[0];
+ vsep = pi->vsep;
+ if (vsep == 'X') {
+ if (pi->spec == 'c')
+ vsep = '\0';
+ else
+ vsep = ' ';
+ }
+ info.begin = info.end = &vsep;
+ if (vsep) info.end++;
+ info.is_vec = 0;
+
+ if (pi->is_short) {
+ if (pi->spec == 'p') {
+ PRINTVECTOR_P(io, &info, argp, 8, vushortarg, __printf_render_ptr, ret);
+ } else {
+ PRINTVECTOR(io, &info, argp, 8, unsigned int, vushortarg, __printf_render_int, ret);
+ }
+ } else if (pi->is_long) {
+ info.is_long = 0;
+ if (pi->spec == 'p') {
+ PRINTVECTOR_P(io, &info, argp, 4, vuintarg, __printf_render_ptr, ret);
+ } else {
+ PRINTVECTOR(io, &info, argp, 4, unsigned int, vuintarg, __printf_render_int, ret);
+ }
+#ifdef V64TYPE
+ } else if (pi->is_long_double) {
+ switch (pi->spec) {
+ case 'a':
+ case 'A':
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'g':
+ case 'G':
+ info.is_long_double = 0;
+ PRINTVECTOR(io, &info, argp, 2, double, vdoublearg, __printf_render_float, ret);
+ break;
+ case 'p':
+ info.is_long_double = 0;
+ PRINTVECTOR_P(io, &info, argp, 2, vulonglongarg, __printf_render_ptr, ret);
+ break;
+ case 'd':
+ case 'i':
+ case 'u':
+ case 'o':
+ case 'x':
+ case 'X':
+ PRINTVECTOR(io, &info, argp, 2, unsigned long long, vulonglongarg, __printf_render_int, ret);
+ break;
+ default:
+ /*
+ * The default case should never
+ * happen.
+ */
+ case 'c':
+ info.is_long_double = 0;
+ PRINTVECTOR(io, &info, argp, 16, unsigned int, vuchararg, __printf_render_chr, ret);
+ }
+#endif /* V64TYPE */
+ } else {
+ switch (pi->spec) {
+ case 'a':
+ case 'A':
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'g':
+ case 'G':
+ PRINTVECTOR(io, &info, argp, 4, double, vfloatarg, __printf_render_float, ret);
+ break;
+ default:
+ /*
+ * The default case should never
+ * happen.
+ */
+ case 'p':
+ PRINTVECTOR_P(io, &info, argp, 16, vuchararg, __printf_render_ptr, ret);
+ break;
+ case 'd':
+ case 'i':
+ case 'u':
+ case 'o':
+ case 'x':
+ case 'X':
+ info.is_char = 1;
+ PRINTVECTOR(io, &info, argp, 16, unsigned int, vuchararg, __printf_render_int, ret);
+ break;
+ case 'c':
+ PRINTVECTOR(io, &info, argp, 16, unsigned int, vuchararg, __printf_render_chr, ret);
+ }
+ }
+ return ret;
+}
+#endif /* VECTORS */