[apple/libc.git] / stdio / xprintf_domain.c

/*
 * Copyright (c) 2012 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <printf.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>
#include "xprintf_domain.h"
#include "xprintf_private.h"

/* These are flag characters and can never be used as conversion specifiers */
static const char _printf_tbl_flags[] = "#$'*+,-.0123456789:;L_hjlqtvz";

struct _printf_tbl_defaults_fbsd {
    const char *spec;
    printf_arginfo_function *arginfo;
    printf_render *render;
};
static struct _printf_tbl_defaults_fbsd _printf_tbl_defaults_fbsd[] = {
    {"%",		__printf_arginfo_pct,	__printf_render_pct},
    {"AEFGaefg",	__printf_arginfo_float,	__printf_render_float},
    {"Cc",		__printf_arginfo_chr,	__printf_render_chr},
    {"DOUXdioux",	__printf_arginfo_int,	__printf_render_int},
    {"Ss",		__printf_arginfo_str,	__printf_render_str},
    {"p",		__printf_arginfo_ptr,	__printf_render_ptr},
};
struct _printf_tbl_defaults_glibc {
    const char *spec;
    printf_arginfo_function *arginfo;
    printf_function *render;
};
static struct _printf_tbl_defaults_glibc _printf_tbl_defaults_glibc[] = {
    {"n",		__printf_arginfo_n,	__printf_render_n},
};

static printf_domain_t xprintf_domain_default;
#ifdef XPRINTF_DEBUG
__private_extern__ printf_domain_t xprintf_domain_global = NULL;
#endif

__private_extern__ pthread_once_t __xprintf_domain_once = PTHREAD_ONCE_INIT;

__private_extern__ void
__xprintf_domain_init(void)
{
    xprintf_domain_default = (printf_domain_t)calloc(
#ifdef XPRINTF_DEBUG
						     2,
#else
						     1,
#endif
						     sizeof(*xprintf_domain_default));
    if(xprintf_domain_default == NULL)
	LIBC_ABORT("No memory");

    xprintf_domain_default->rwlock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER;
    {
	const char *cp;
	for(cp = _printf_tbl_flags; *cp; cp++)
	    xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_FLAG;
    }
    {
	struct _printf_tbl_defaults_fbsd *d = _printf_tbl_defaults_fbsd;
	int n = sizeof(_printf_tbl_defaults_fbsd) / sizeof(*_printf_tbl_defaults_fbsd);
	for(; n > 0; d++, n--) {
	    for(const char *cp = d->spec; *cp; cp++) {
		xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_FBSD_API;
		xprintf_domain_default->tbl[printf_tbl_index(*cp)] = (struct _printf_tbl){d->arginfo, d->render, NULL};
	    }
	}
    }
    {
	struct _printf_tbl_defaults_glibc *d = _printf_tbl_defaults_glibc;
	int n = sizeof(_printf_tbl_defaults_glibc) / sizeof(*_printf_tbl_defaults_glibc);
	for(; n > 0; d++, n--) {
	    for(const char *cp = d->spec; *cp; cp++) {
		xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_GLIBC_API;
		xprintf_domain_default->tbl[printf_tbl_index(*cp)] = (struct _printf_tbl){d->arginfo, d->render, NULL};
	    }
	}
    }
#ifdef XPRINTF_DEBUG
    xprintf_domain_global = xprintf_domain_default + 1;
    *xprintf_domain_global = *xprintf_domain_default;
#endif
}

printf_domain_t
copy_printf_domain(printf_domain_t src)
{
    printf_domain_t restrict copy;

    if(!src) {
	errno = EINVAL;
	return NULL;
    }
    copy = (printf_domain_t)MALLOC(sizeof(*copy));
    if(!copy) return NULL;
    xprintf_domain_init();
    pthread_rwlock_rdlock(&src->rwlock);
    *copy = *src;
    pthread_rwlock_unlock(&src->rwlock);
    copy->rwlock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER;
    return copy;
}

void
free_printf_domain(printf_domain_t d)
{
    if(!d) return;
    pthread_rwlock_destroy(&d->rwlock);
    free(d);
}

printf_domain_t
new_printf_domain(void)
{
    printf_domain_t restrict d;

    xprintf_domain_init();

    d = (printf_domain_t)MALLOC(sizeof(*d));
    if(!d) return NULL;
    *d = *xprintf_domain_default;
    return d;
}

int
register_printf_domain_function(printf_domain_t d, int spec, printf_function *render, printf_arginfo_function *arginfo, void *context)
{
    xprintf_domain_init();

    if(!d || !printf_tbl_in_range(spec)) {
	errno = EINVAL;
	return -1;
    }
    xprintf_domain_init();

    switch(d->type[printf_tbl_index(spec)]) {
    case PRINTF_DOMAIN_FLAG:
	errno = EINVAL;
	return -1;
    default:
	pthread_rwlock_wrlock(&d->rwlock);
	if(!render || !arginfo) {
	    d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_UNUSED;
	} else {
	    d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_GLIBC_API;
	    d->tbl[printf_tbl_index(spec)] = (struct _printf_tbl){arginfo, render, context};
	}
	pthread_rwlock_unlock(&d->rwlock);
    }

    return 0;
}

__private_extern__ int
register_printf_domain_render(printf_domain_t d, int spec, printf_render *render, printf_arginfo_function *arginfo)
{
    xprintf_domain_init();

    if(!d || !printf_tbl_in_range(spec)) {
	errno = EINVAL;
	return -1;
    }
    xprintf_domain_init();

    switch(d->type[printf_tbl_index(spec)]) {
    case PRINTF_DOMAIN_FLAG:
	errno = EINVAL;
	return -1;
    default:
	pthread_rwlock_wrlock(&d->rwlock);
	if(!render || !arginfo) {
	    d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_UNUSED;
	} else {
	    d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_FBSD_API;
	    d->tbl[printf_tbl_index(spec)] = (struct _printf_tbl){arginfo, render, NULL};
	}
	pthread_rwlock_unlock(&d->rwlock);
    }

    return 0;
}

int
register_printf_domain_render_std(printf_domain_t d, const char *specs)
{
    int ret = 0;

    for (; *specs != '\0'; specs++) {
	switch (*specs) {
	case 'H':
	    ret = register_printf_domain_render(d, *specs,
		__printf_render_hexdump,
		__printf_arginfo_hexdump);
	    break;
	case 'M':
	    ret = register_printf_domain_render(d, *specs,
		__printf_render_errno,
		__printf_arginfo_errno);
	    break;
	case 'Q':
	    ret = register_printf_domain_render(d, *specs,
		__printf_render_quote,
		__printf_arginfo_quote);
	    break;
	case 'T':
	    ret = register_printf_domain_render(d, *specs,
		__printf_render_time,
		__printf_arginfo_time);
	    break;
	case 'V':
	    ret = register_printf_domain_render(d, *specs,
		__printf_render_vis,
		__printf_arginfo_vis);
	    break;
	default:
	    errno = EINVAL;
	    return (-1);
	}
	if(ret < 0) return ret;
    }
    return (0);
}
Commit	Line	Data
6465356a A	1	/*
	2	* Copyright (c) 2012 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include <printf.h>
	25	#include <pthread.h>
	26	#include <stdlib.h>
	27	#include <errno.h>
	28	#include "xprintf_domain.h"
	29	#include "xprintf_private.h"
	30
	31	/* These are flag characters and can never be used as conversion specifiers */
	32	static const char _printf_tbl_flags[] = "#$'*+,-.0123456789:;L_hjlqtvz";
	33
	34	struct _printf_tbl_defaults_fbsd {
	35	const char *spec;
	36	printf_arginfo_function *arginfo;
	37	printf_render *render;
	38	};
	39	static struct _printf_tbl_defaults_fbsd _printf_tbl_defaults_fbsd[] = {
	40	{"%", __printf_arginfo_pct, __printf_render_pct},
	41	{"AEFGaefg", __printf_arginfo_float, __printf_render_float},
	42	{"Cc", __printf_arginfo_chr, __printf_render_chr},
	43	{"DOUXdioux", __printf_arginfo_int, __printf_render_int},
	44	{"Ss", __printf_arginfo_str, __printf_render_str},
	45	{"p", __printf_arginfo_ptr, __printf_render_ptr},
	46	};
	47	struct _printf_tbl_defaults_glibc {
	48	const char *spec;
	49	printf_arginfo_function *arginfo;
	50	printf_function *render;
	51	};
	52	static struct _printf_tbl_defaults_glibc _printf_tbl_defaults_glibc[] = {
	53	{"n", __printf_arginfo_n, __printf_render_n},
	54	};
	55
	56	static printf_domain_t xprintf_domain_default;
	57	#ifdef XPRINTF_DEBUG
	58	__private_extern__ printf_domain_t xprintf_domain_global = NULL;
	59	#endif
	60
	61	__private_extern__ pthread_once_t __xprintf_domain_once = PTHREAD_ONCE_INIT;
	62
	63	__private_extern__ void
	64	__xprintf_domain_init(void)
65	{
66	xprintf_domain_default = (printf_domain_t)calloc(
67	#ifdef XPRINTF_DEBUG
68	2,
69	#else
70	1,
71	#endif
72	sizeof(*xprintf_domain_default));
73	if(xprintf_domain_default == NULL)
74	LIBC_ABORT("No memory");
75
76	xprintf_domain_default->rwlock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER;
77	{
78	const char *cp;
79	for(cp = _printf_tbl_flags; *cp; cp++)
80	xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_FLAG;
81	}
82	{
83	struct _printf_tbl_defaults_fbsd *d = _printf_tbl_defaults_fbsd;
84	int n = sizeof(_printf_tbl_defaults_fbsd) / sizeof(*_printf_tbl_defaults_fbsd);
85	for(; n > 0; d++, n--) {
86	for(const char cp = d->spec; cp; cp++) {
87	xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_FBSD_API;
88	xprintf_domain_default->tbl[printf_tbl_index(*cp)] = (struct _printf_tbl){d->arginfo, d->render, NULL};
89	}
90	}
91	}
92	{
93	struct _printf_tbl_defaults_glibc *d = _printf_tbl_defaults_glibc;
94	int n = sizeof(_printf_tbl_defaults_glibc) / sizeof(*_printf_tbl_defaults_glibc);
95	for(; n > 0; d++, n--) {
96	for(const char cp = d->spec; cp; cp++) {
97	xprintf_domain_default->type[printf_tbl_index(*cp)] = PRINTF_DOMAIN_GLIBC_API;
98	xprintf_domain_default->tbl[printf_tbl_index(*cp)] = (struct _printf_tbl){d->arginfo, d->render, NULL};
99	}
100	}
101	}
102	#ifdef XPRINTF_DEBUG
103	xprintf_domain_global = xprintf_domain_default + 1;
104	xprintf_domain_global = xprintf_domain_default;
105	#endif
106	}
107
108	printf_domain_t
109	copy_printf_domain(printf_domain_t src)
110	{
111	printf_domain_t restrict copy;
112
113	if(!src) {
114	errno = EINVAL;
115	return NULL;
116	}
117	copy = (printf_domain_t)MALLOC(sizeof(*copy));
118	if(!copy) return NULL;
119	xprintf_domain_init();
120	pthread_rwlock_rdlock(&src->rwlock);
121	copy = src;
122	pthread_rwlock_unlock(&src->rwlock);
123	copy->rwlock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER;
124	return copy;
125	}
126
127	void
128	free_printf_domain(printf_domain_t d)
129	{
130	if(!d) return;
131	pthread_rwlock_destroy(&d->rwlock);
132	free(d);
133	}
134
135	printf_domain_t
136	new_printf_domain(void)
137	{
138	printf_domain_t restrict d;
139
140	xprintf_domain_init();
141
142	d = (printf_domain_t)MALLOC(sizeof(*d));
143	if(!d) return NULL;
144	d = xprintf_domain_default;
145	return d;
146	}
147
148	int
149	register_printf_domain_function(printf_domain_t d, int spec, printf_function render, printf_arginfo_function arginfo, void *context)
150	{
151	xprintf_domain_init();
152
153	if(!d \|\| !printf_tbl_in_range(spec)) {
154	errno = EINVAL;
155	return -1;
156	}
157	xprintf_domain_init();
158
159	switch(d->type[printf_tbl_index(spec)]) {
160	case PRINTF_DOMAIN_FLAG:
161	errno = EINVAL;
162	return -1;
163	default:
164	pthread_rwlock_wrlock(&d->rwlock);
165	if(!render \|\| !arginfo) {
166	d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_UNUSED;
167	} else {
168	d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_GLIBC_API;
169	d->tbl[printf_tbl_index(spec)] = (struct _printf_tbl){arginfo, render, context};
170	}
171	pthread_rwlock_unlock(&d->rwlock);
172	}
173
174	return 0;
175	}
176
177	__private_extern__ int
178	register_printf_domain_render(printf_domain_t d, int spec, printf_render render, printf_arginfo_function arginfo)
179	{
180	xprintf_domain_init();
181
182	if(!d \|\| !printf_tbl_in_range(spec)) {
183	errno = EINVAL;
184	return -1;
185	}
186	xprintf_domain_init();
187
188	switch(d->type[printf_tbl_index(spec)]) {
189	case PRINTF_DOMAIN_FLAG:
190	errno = EINVAL;
191	return -1;
192	default:
193	pthread_rwlock_wrlock(&d->rwlock);
194	if(!render \|\| !arginfo) {
195	d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_UNUSED;
196	} else {
197	d->type[printf_tbl_index(spec)] = PRINTF_DOMAIN_FBSD_API;
198	d->tbl[printf_tbl_index(spec)] = (struct _printf_tbl){arginfo, render, NULL};
199	}
200	pthread_rwlock_unlock(&d->rwlock);
201	}
202
203	return 0;
204	}
205
206	int
207	register_printf_domain_render_std(printf_domain_t d, const char *specs)
208	{
209	int ret = 0;
210
211	for (; *specs != '\0'; specs++) {
212	switch (*specs) {
213	case 'H':
214	ret = register_printf_domain_render(d, *specs,
215	__printf_render_hexdump,
216	__printf_arginfo_hexdump);
217	break;
218	case 'M':
219	ret = register_printf_domain_render(d, *specs,
220	__printf_render_errno,
221	__printf_arginfo_errno);
222	break;
223	case 'Q':
224	ret = register_printf_domain_render(d, *specs,
225	__printf_render_quote,
226	__printf_arginfo_quote);
227	break;
228	case 'T':
229	ret = register_printf_domain_render(d, *specs,
230	__printf_render_time,
231	__printf_arginfo_time);
232	break;
233	case 'V':
234	ret = register_printf_domain_render(d, *specs,
235	__printf_render_vis,
236	__printf_arginfo_vis);
237	break;
238	default:
239	errno = EINVAL;
240	return (-1);
241	}
242	if(ret < 0) return ret;
243	}
244	return (0);
245	}