Ejemplo n.º 1
0
int
main ()
{
  struct locale_dependent_values expected_results;
  locale_t mixed1;
  locale_t mixed2;

  /* Set up a locale which is a mix between different system locales.  */
  setlocale (LC_ALL, "en_US.UTF-8");
  setlocale (LC_NUMERIC, "de_DE.UTF-8");
  setlocale (LC_TIME, "fr_FR.UTF-8");
  get_locale_dependent_values (&expected_results);

  /* Save the locale in a locale_t object.  */
  mixed1 = duplocale (LC_GLOBAL_LOCALE);
  ASSERT (mixed1 != NULL);

  /* Use a per-thread locale.  */
  uselocale (newlocale (LC_ALL_MASK, "es_ES.UTF-8", NULL));

  /* Save the locale in a locale_t object again.  */
  mixed2 = duplocale (LC_GLOBAL_LOCALE);
  ASSERT (mixed2 != NULL);

  /* Set up a default locale.  */
  setlocale (LC_ALL, "C");
  uselocale (LC_GLOBAL_LOCALE);
  {
    struct locale_dependent_values c_results;
    get_locale_dependent_values (&c_results);
  }

  /* Now use the saved locale mixed1 again.  */
  setlocale (LC_ALL, "C");
  uselocale (LC_GLOBAL_LOCALE);
  uselocale (mixed1);
  {
    struct locale_dependent_values results;
    get_locale_dependent_values (&results);
    ASSERT (strcmp (results.monetary, expected_results.monetary) == 0);
    ASSERT (strcmp (results.numeric, expected_results.numeric) == 0);
    ASSERT (strcmp (results.time, expected_results.time) == 0);
  }

  /* Now use the saved locale mixed2 again.  */
  setlocale (LC_ALL, "C");
  uselocale (LC_GLOBAL_LOCALE);
  uselocale (mixed2);
  {
    struct locale_dependent_values results;
    get_locale_dependent_values (&results);
    ASSERT (strcmp (results.monetary, expected_results.monetary) == 0);
    ASSERT (strcmp (results.numeric, expected_results.numeric) == 0);
    ASSERT (strcmp (results.time, expected_results.time) == 0);
  }

  return 0;
}
Ejemplo n.º 2
0
locale_t
newlocale(int catmask, const char *locname, locale_t base)
{
	locale_t loc;
	int i, e;

	if (catmask & ~(LC_ALL_MASK)) {
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * Technically passing LC_GLOBAL_LOCALE here is illegal,
	 * but we allow it.
	 */
	if (base == NULL || base == ___global_locale) {
		loc = duplocale(___global_locale);
	} else {
		loc = duplocale(base);
	}
	if (loc == NULL) {
		return (NULL);
	}

	for (i = 0; i < LC_ALL; i++) {
		struct locdata *ldata;
		loc->loaded[i] = 0;
		if (((1 << i) & catmask) == 0) {
			/* Default to base locale if not overriding */
			continue;
		}
		ldata = locdata_get(i, locname);
		if (ldata == NULL) {
			e = errno;
			freelocale(loc);
			errno = e;
			return (NULL);
		}
		loc->locdata[i] = ldata;
	}
	loc->collate = loc->locdata[LC_COLLATE]->l_data[0];
	loc->ctype = loc->locdata[LC_CTYPE]->l_data[0];
	loc->runelocale = loc->locdata[LC_CTYPE]->l_data[1];
	loc->messages = loc->locdata[LC_MESSAGES]->l_data[0];
	loc->monetary = loc->locdata[LC_MONETARY]->l_data[0];
	loc->numeric = loc->locdata[LC_NUMERIC]->l_data[0];
	loc->time = loc->locdata[LC_TIME]->l_data[0];
	freelocale(base);

	return (mklocname(loc));
}
Ejemplo n.º 3
0
int
main (void)
{
  locale_t l;
  locale_t l2;
  int result;

  l = newlocale (1 << LC_ALL, "de_DE.ISO-8859-1", NULL);
  if (l == NULL)
    {
      printf ("newlocale failed: %m\n");
      exit (EXIT_FAILURE);
    }
  puts ("Running tests of created locale");
  result = do_test (l);

  l2 = duplocale (l);
  if (l2 == NULL)
    {
      printf ("duplocale failed: %m\n");
      exit (EXIT_FAILURE);
    }
  freelocale (l);
  puts ("Running tests of duplicated locale");
  result |= do_test (l2);

  return result;
}
Ejemplo n.º 4
0
static int
do_test (void)
{
  locale_t d = duplocale (LC_GLOBAL_LOCALE);
  if (d != (locale_t) 0)
    freelocale (d);
  return 0;
}
Ejemplo n.º 5
0
void locale_check_functions(locale_t l)
{
    (void)duplocale(l);
    (void)freelocale(l);
    (void)localeconv();
    (void)newlocale(0, "C", l);
    (void)setlocale(0, "C");
    (void)uselocale(l);
}
Ejemplo n.º 6
0
TEST(locale, duplocale) {
  locale_t cloned_global = duplocale(LC_GLOBAL_LOCALE);
  ASSERT_TRUE(cloned_global != NULL);
  freelocale(cloned_global);
}
Ejemplo n.º 7
0
locale_t
rpl_duplocale (locale_t locale)
{
  /* Work around crash in the duplocale function in glibc < 2.12.
     See <http://sourceware.org/bugzilla/show_bug.cgi?id=10969>.
     Also, on AIX 7.1, duplocale(LC_GLOBAL_LOCALE) returns (locale_t)0 with
     errno set to EINVAL.  */
  if (locale == LC_GLOBAL_LOCALE)
    {
      /* Create a copy of the locale by fetching the name of each locale
         category, starting with LC_CTYPE.  */
      static struct { int cat; int mask; } const categories[] =
        {
            { LC_NUMERIC,        LC_NUMERIC_MASK },
            { LC_TIME,           LC_TIME_MASK },
            { LC_COLLATE,        LC_COLLATE_MASK },
            { LC_MONETARY,       LC_MONETARY_MASK },
            { LC_MESSAGES,       LC_MESSAGES_MASK }
#ifdef LC_PAPER
          , { LC_PAPER,          LC_PAPER_MASK }
#endif
#ifdef LC_NAME
          , { LC_NAME,           LC_NAME_MASK }
#endif
#ifdef LC_ADDRESS
          , { LC_ADDRESS,        LC_ADDRESS_MASK }
#endif
#ifdef LC_TELEPHONE
          , { LC_TELEPHONE,      LC_TELEPHONE_MASK }
#endif
#ifdef LC_MEASUREMENT
          , { LC_MEASUREMENT,    LC_MEASUREMENT_MASK }
#endif
#ifdef LC_IDENTIFICATION
          , { LC_IDENTIFICATION, LC_IDENTIFICATION_MASK }
#endif
        };
      const char *base_name;
      locale_t base_copy;
      unsigned int i;

      base_name = setlocale (LC_CTYPE, NULL);
      base_copy = newlocale (LC_ALL_MASK, base_name, NULL);
      if (base_copy == NULL)
        return NULL;

      for (i = 0; i < SIZEOF (categories); i++)
        {
          int category = categories[i].cat;
          int category_mask = categories[i].mask;
          const char *name = setlocale (category, NULL);
          if (strcmp (name, base_name) != 0)
            {
              locale_t copy = newlocale (category_mask, name, base_copy);
              if (copy == NULL)
                {
                  int saved_errno = errno;
                  freelocale (base_copy);
                  errno = saved_errno;
                  return NULL;
                }
              /* No need to call freelocale (base_copy) if copy != base_copy;
                 the newlocale function already takes care of doing it.  */
              base_copy = copy;
            }
        }

      return base_copy;
    }

  return duplocale (locale);
}