struct __locale_t *
_newlocale_r (struct _reent *p, int category_mask, const char *locale,
struct __locale_t *base)
{
#ifndef _MB_CAPABLE
return __get_C_locale ();
#else /* _MB_CAPABLE */
char new_categories[_LC_LAST][ENCODING_LEN + 1];
struct __locale_t tmp_locale, *new_locale;
int i;
/* Convert LC_ALL_MASK to a mask containing all valid MASK values.
This simplifies the code below. */
if (category_mask & LC_ALL_MASK)
{
category_mask &= ~LC_ALL_MASK;
category_mask |= LC_VALID_MASK;
}
/* Check for invalid mask values and valid locale ptr. */
if ((category_mask & ~LC_VALID_MASK) || !locale)
{
p->_errno = EINVAL;
return NULL;
}
/* If the new locale is supposed to be all default locale, just return
a pointer to the default locale. */
if ((!base && category_mask == 0)
|| (category_mask == LC_VALID_MASK
&& (!strcmp (locale, "C") || !strcmp (locale, "POSIX"))))
return __get_C_locale ();
/* Start with setting all values to the default locale values. */
tmp_locale = *__get_C_locale ();
/* Fill out new category strings. */
for (i = 1; i < _LC_LAST; ++i)
{
if (((1 << i) & category_mask) != 0)
{
/* If locale is "", fetch from environment. Otherwise use locale
name verbatim. */
const char *cat = (locale[0] == '\0') ? __get_locale_env (p, i)
: locale;
if (strlen (cat) > ENCODING_LEN)
{
p->_errno = EINVAL;
return NULL;
}
strcpy (new_categories[i], cat);
}
else
strcpy (new_categories[i], base ? base->categories[i] : "C");
}
/* Now go over all categories and set them. */
for (i = 1; i < _LC_LAST; ++i)
{
/* If we have a base locale, and the category is not in category_mask
or the new category is the base categroy, just copy over. */
if (base && (((1 << i) & category_mask) == 0
|| !strcmp (base->categories[i], new_categories[i])))
{
strcpy (tmp_locale.categories[i], new_categories[i]);
if (i == LC_CTYPE)
{
tmp_locale.wctomb = base->wctomb;
tmp_locale.mbtowc = base->mbtowc;
tmp_locale.cjk_lang = base->cjk_lang;
tmp_locale.ctype_ptr = base->ctype_ptr;
}
#ifdef __HAVE_LOCALE_INFO__
/* Mark the values as "has still to be copied". We do this in
two steps to simplify freeing new locale types in case of a
subsequent error. */
tmp_locale.lc_cat[i].ptr = base->lc_cat[i].ptr;
tmp_locale.lc_cat[i].buf = (void *) -1;
#else /* !__HAVE_LOCALE_INFO__ */
if (i == LC_CTYPE)
strcpy (tmp_locale.ctype_codeset, base->ctype_codeset);
else if (i == LC_MESSAGES)
strcpy (tmp_locale.message_codeset, base->message_codeset);
#endif /* !__HAVE_LOCALE_INFO__ */
}
/* Otherwise, if the category is in category_mask, create entry. */
else if (((1 << i) & category_mask) != 0)
{
/* Nothing to do for "C"/"POSIX" locale. */
if (!strcmp (new_categories[i], "C")
|| !strcmp (new_categories[i], "POSIX"))
continue;
/* Otherwise load locale data. */
else if (!__loadlocale (&tmp_locale, i, new_categories[i]))
goto error;
}
}
/* Allocate new locale_t. */
new_locale = (struct __locale_t *) _calloc_r (p, 1, sizeof *new_locale);
if (!new_locale)
goto error;
if (base)
{
#ifdef __HAVE_LOCALE_INFO__
/* Step 2 of copying over.. Make sure to invalidate the copied buffer
pointers in base, so the subsequent _freelocale_r (base) doesn't free
the buffers now used in the new locale. */
for (i = 1; i < _LC_LAST; ++i)
if (tmp_locale.lc_cat[i].buf == (const void *) -1)
{
tmp_locale.lc_cat[i].buf = base->lc_cat[i].buf;
base->lc_cat[i].ptr = base->lc_cat[i].buf = NULL;
}
#endif /* __HAVE_LOCALE_INFO__ */
_freelocale_r (p, base);
}
*new_locale = tmp_locale;
return new_locale;
error:
/* An error occured while we had already (potentially) allocated memory.
Free memory and return NULL. errno is supposed to be set already. */
#ifdef __HAVE_LOCALE_INFO__
for (i = 1; i < _LC_LAST; ++i)
if (((1 << i) & category_mask) != 0
&& tmp_locale.lc_cat[i].buf
&& tmp_locale.lc_cat[i].buf != (const void *) -1)
{
_free_r (p, (void *) tmp_locale.lc_cat[i].ptr);
_free_r (p, tmp_locale.lc_cat[i].buf);
}
#endif /* __HAVE_LOCALE_INFO__ */
return NULL;
#endif /* _MB_CAPABLE */
}
void *calloc(size_t n, size_t size)
{
return _calloc_r(_REENT, n, size);
}
void *calloc(size_t sz1, size_t sz2)
{
return _calloc_r(_REENT, sz1, sz2);
}
