# setlocale

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           setlocale — set program locale
    


## SYNOPSIS



           #include <locale.h>
    
           char *setlocale(int _category_ , const char *_locale_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           The _setlocale_() function selects the appropriate piece of the
           global locale, as specified by the _category_ and _locale_ arguments,
           and can be used to change or query the entire global locale or
           portions thereof. The value LC_ALL for _category_ names the entire
           global locale; other values for _category_ name only a part of the
           global locale:
    
           LC_COLLATE  Affects the behavior of regular expressions and the
                       collation functions.
    
           LC_CTYPE    Affects the behavior of regular expressions, character
                       classification, character conversion functions, and
                       wide-character functions.
    
           LC_MESSAGES Affects the affirmative and negative response
                       expressions returned by _nl_langinfo_() and the way
                       message catalogs are located. It may also affect the
                       behavior of functions that return or write message
                       strings.
    
           LC_MONETARY Affects the behavior of functions that handle monetary
                       values.
    
           LC_NUMERIC  Affects the behavior of functions that handle numeric
                       values.
    
           LC_TIME     Affects the behavior of the time conversion functions.
    
           The _locale_ argument is a pointer to a character string containing
           the required setting of _category_.  The contents of this string are
           implementation-defined. In addition, the following preset values
           of _locale_ are defined for all settings of _category_ :
    
           "POSIX"     Specifies the minimal environment for C-language
                       translation called the POSIX locale. The POSIX locale
                       is the default global locale at entry to _main_().
    
           "C"         Equivalent to **"POSIX"**.
    
           ""          Specifies an implementation-defined native
                       environment.  The determination of the name of the new
                       locale for the specified category depends on the value
                       of the associated environment variables, _LC_*_ and
                       _LANG_ ; see the Base Definitions volume of POSIX.1‐2017,
                       _Chapter 7_ , _Locale_ and _Chapter 8_ , _Environment_
                       _Variables_.
    
           A null pointer
                       Directs _setlocale_() to query the current global locale
                       setting and return the name of the locale if _category_
                       is not LC_ALL, or a string which encodes the locale
                       name(s) for all of the individual categories if
                       _category_ is LC_ALL.
    
           Setting all of the categories of the global locale is similar to
           successively setting each individual category of the global
           locale, except that all error checking is done before any actions
           are performed. To set all the categories of the global locale,
           _setlocale_() can be invoked as:
    
               setlocale(LC_ALL, "");
    
           In this case, _setlocale_() shall first verify that the values of
           all the environment variables it needs according to the precedence
           rules (described in the Base Definitions volume of POSIX.1‐2017,
           _Chapter 8_ , _Environment Variables_) indicate supported locales. If
           the value of any of these environment variable searches yields a
           locale that is not supported (and non-null), _setlocale_() shall
           return a null pointer and the global locale shall not be changed.
           If all environment variables name supported locales, _setlocale_()
           shall proceed as if it had been called for each category, using
           the appropriate value from the associated environment variable or
           from the implementation-defined default if there is no such value.
    
           The global locale established using _setlocale_() shall only be used
           in threads for which no current locale has been set using
           _uselocale_() or whose current locale has been set to the global
           locale using _uselocale_(LC_GLOBAL_LOCALE)_._
    
           The implementation shall behave as if no function defined in this
           volume of POSIX.1‐2017 calls _setlocale_().
    
           The _setlocale_() function need not be thread-safe.
    


## RETURN VALUE



           Upon successful completion, _setlocale_() shall return the string
           associated with the specified category for the new locale.
           Otherwise, _setlocale_() shall return a null pointer and the global
           locale shall not be changed.
    
           A null pointer for _locale_ shall cause _setlocale_() to return a
           pointer to the string associated with the specified _category_ for
           the current global locale. The global locale shall not be changed.
    
           The string returned by _setlocale_() is such that a subsequent call
           with that string and its associated _category_ shall restore that
           part of the global locale. The application shall not modify the
           string returned.  The returned string pointer might be invalidated
           or the string content might be overwritten by a subsequent call to
           _setlocale_().  The returned pointer might also be invalidated if
           the calling thread is terminated.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           The following code illustrates how a program can initialize the
           international environment for one language, while selectively
           modifying the global locale such that regular expressions and
           string operations can be applied to text recorded in a different
           language:
    
               setlocale(LC_ALL, "De");
               setlocale(LC_COLLATE, "Fr@dict");
    
           Internationalized programs can initiate language operation
           according to environment variable settings (see the Base
           Definitions volume of POSIX.1‐2017, _Section 8.2_ ,
           _Internationalization Variables_) by calling _setlocale_() as follows:
    
               setlocale(LC_ALL, "");
    
           Changing the setting of _LC_MESSAGES_ has no effect on catalogs that
           have already been opened by calls to _catopen_().
    
           In order to make use of different locale settings while multiple
           threads are running, applications should use _uselocale_() in
           preference to _setlocale_().
    


## RATIONALE



           References to the international environment or locale in the
           following text relate to the global locale for the process. This
           can be overridden for individual threads using _uselocale_().
    
           The ISO C standard defines a collection of functions to support
           internationalization.  One of the most significant aspects of
           these functions is a facility to set and query the _international_
           _environment_.  The international environment is a repository of
           information that affects the behavior of certain functionality,
           namely:
    
            1. Character handling
    
            2. Collating
    
            3. Date/time formatting
    
            4. Numeric editing
    
            5. Monetary formatting
    
            6. Messaging
    
           The _setlocale_() function provides the application developer with
           the ability to set all or portions, called _categories_ , of the
           international environment.  These categories correspond to the
           areas of functionality mentioned above. The syntax for _setlocale_()
           is as follows:
    
               char *setlocale(int _category_ , const char *_locale_);
    
           where _category_ is the name of one of following categories, namely:
    
                  LC_COLLATE LC_CTYPE LC_MESSAGES LC_MONETARY LC_NUMERIC
                  LC_TIME
    
           In addition, a special value called LC_ALL directs _setlocale_() to
           set all categories.
    
           There are two primary uses of _setlocale_():
    
            1. Querying the international environment to find out what it is
               set to
    
            2. Setting the international environment, or _locale_ , to a
               specific value
    
           The behavior of _setlocale_() in these two areas is described below.
           Since it is difficult to describe the behavior in words, examples
           are used to illustrate the behavior of specific uses.
    
           To query the international environment, _setlocale_() is invoked
           with a specific category and the null pointer as the locale. The
           null pointer is a special directive to _setlocale_() that tells it
           to query rather than set the international environment.  The
           following syntax is used to query the name of the international
           environment:
    
               setlocale({LC_ALL, LC_COLLATE, LC_CTYPE, LC_MESSAGES, LC_MONETARY, \
                   LC_NUMERIC, LC_TIME},(char *) NULL);
    
           The _setlocale_() function shall return the string corresponding to
           the current international environment. This value may be used by a
           subsequent call to _setlocale_() to reset the international
           environment to this value. However, it should be noted that the
           return value from _setlocale_() may be a pointer to a static area
           within the function and is not guaranteed to remain unchanged
           (that is, it may be modified by a subsequent call to _setlocale_()).
           Therefore, if the purpose of calling _setlocale_() is to save the
           value of the current international environment so it can be
           changed and reset later, the return value should be copied to an
           array of **char** in the calling program.
    
           There are three ways to set the international environment with
           _setlocale_():
    
           _setlocale_(_category_ , _string_)
                 This usage sets a specific _category_ in the international
                 environment to a specific value corresponding to the value
                 of the _string_.  A specific example is provided below:
    
                     setlocale(LC_ALL, "fr_FR.ISO-8859-1");
    
                 In this example, all categories of the international
                 environment are set to the locale corresponding to the
                 string **"fr_FR.ISO-8859-1"** , or to the French language as
                 spoken in France using the ISO/IEC 8859‐1:1998 standard
                 codeset.
    
                 If the string does not correspond to a valid locale,
                 _setlocale_() shall return a null pointer and the
                 international environment is not changed. Otherwise,
                 _setlocale_() shall return the name of the locale just set.
    
           _setlocale_(_category_ , "C")
                 The ISO C standard states that one locale must exist on all
                 conforming implementations. The name of the locale is C and
                 corresponds to a minimal international environment needed to
                 support the C programming language.
    
           _setlocale_(_category_ , "")
                 This sets a specific category to an implementation-defined
                 default.  This corresponds to the value of the environment
                 variables.
    


## FUTURE DIRECTIONS



           None.
    


* * *