In computing, locale is
a set of parameters that defines
the user's language, country and any special variant preferences that the user
wants to see in their user
interface. Usually a locale identifier consists of at least a language
identifier and a region identifier.

Locale identifiers can be defined in several ways:

[language[_territory][.charset][@modifier]]

Internationalization Variables

This section describes environment variables that are relevant to the operation of internationalized interfaces described in
IEEE Std 1003.1-2001.

Users may use the following environment variables to announce specific localization requirements to applications. Applications
can retrieve this information using the setlocale()
function to initialize the
correct behavior of the internationalized interfaces. The descriptions
of the internationalization environment variables describe
the resulting behavior only when the application locale is initialized
in this way. The use of the internationalization variables
by utilities described in the Shell and Utilities volume of
IEEE Std 1003.1-2001 is described in the ENVIRONMENT
VARIABLES section for those utilities in addition to the global effects
described in this section.

For example:

NLSPATH="/system/nlslib/%N.cat"

defines that catopen() should look for all message catalogs in the directory
/system/nlslib, where the catalog name should be constructed from the name parameter passed to catopen() ( %N ), with the suffix .cat.

Conversion specifications consist of a '%' symbol, followed by a single-letter keyword. The following keywords are
currently defined:

An empty string is substituted if the specified value is not currently defined. The separators underscore ( '_' ) and
period ( '.' ) are not included in the %t and %c conversion specifications.

Templates defined in NLSPATH are separated by colons ( ':' ). A leading or two adjacent colons "::" is
equivalent to specifying %N. For example:

NLSPATH=":%N.cat:/nlslib/%L/%N.cat"

indicates to catopen() that it should look for the requested message catalog in
name, name.cat, and /nlslib/category/name.cat, where category is the
value of the LC_MESSAGES category of the current locale.

Users should not set the NLSPATH variable unless they have a specific reason to override the default system path. Setting
NLSPATH to override the default system path produces undefined results in the standard utilities and in applications with
appropriate privileges.

The environment variables LANG , LC_ALL , LC_COLLATE , LC_CTYPE , LC_MESSAGES ,
LC_MONETARY , LC_NUMERIC , LC_TIME , ^[XSI]  and NLSPATH
 provide for the support of internationalized applications. The
standard utilities shall make use
of these environment variables as described in this section and the
individual ENVIRONMENT VARIABLES sections for the utilities. If
these variables specify locale categories that are not based upon the
same underlying codeset, the results are unspecified.

The values of locale categories shall be determined by a precedence order; the first condition met below determines the
value:

1. 
   

   If the LC_ALL environment variable is defined and is not null, the value of LC_ALL shall be used.

   
   
2. 
   

   If the LC_* environment variable ( LC_COLLATE , LC_CTYPE , LC_MESSAGES , LC_MONETARY ,
   LC_NUMERIC , LC_TIME ) is defined and is not null, the value of the environment variable shall be used to initialize
   the category that corresponds to the environment variable.

   
   
3. 
   

   If the LANG environment variable is defined and is not null, the value of the LANG environment variable shall be
   used.

   
   
4. 
   

   If the LANG environment variable is not set or is set to the empty string, the implementation-defined default locale
   shall be used.

   
   

If the locale value is "C" or "POSIX", the POSIX locale shall be used and the standard utilities behave in
accordance with the rules in POSIX Locale for the associated category.

If the locale value begins with a slash, it shall be interpreted as the pathname of a file that was created in the output format
used by the localedef utility; see OUTPUT FILES under localedef. Referencing such a pathname shall result in that locale being used for the
indicated category.

^[XSI]
If the locale value has the form:

language[_territory][.codeset]

it refers to an implementation-provided locale, where settings of language, territory, and codeset are
implementation-defined.

LC_COLLATE , LC_CTYPE , LC_MESSAGES , LC_MONETARY , LC_NUMERIC , and LC_TIME are
defined to accept an additional field @ modifier,
which allows the user to select a specific instance of localization
data
within a single category (for example, for selecting the dictionary as
opposed to the character ordering of data). The syntax for
these environment variables is thus defined as:

[language[_territory][.codeset][@modifier]]

For example, if a user wanted to interact with the system in French, but required to sort German text files, LANG and
LC_COLLATE could be defined as:

LANG=Fr_FR
LC_COLLATE=De_DE

This could be extended to select dictionary collation (say) by use of the @ modifier field; for example:

LC_COLLATE=De_DE@dict

An implementation may support other formats.

If the locale value is not recognized by the implementation, the behavior is unspecified.

At runtime, these values are bound to a program's locale by calling the setlocale() function.

Additional criteria for determining a valid locale name are implementation-defined.

7. Locale

7.1 General

A locale is the definition of the subset of a user's environment that depends
on language and cultural conventions. It is made up from one or more categories.
Each category is identified by its name and controls specific aspects of the
behavior of components of the system. Category names correspond to the following
environment variable names:

The standard utilities in the Shell and Utilities volume of
IEEE Std 1003.1-2001 shall base their behavior on the current locale, as defined
in the ENVIRONMENT VARIABLES section for each utility. The behavior of some of
the C-language functions defined in the System Interfaces volume of
IEEE Std 1003.1-2001 shall also be modified based on the current locale, as
defined by the last call to setlocale().

Locales other than those supplied by the implementation can be created via
the localedef utility, provided
that the _POSIX2_LOCALEDEF symbol is defined on the system. Even if localedef is not provided, all
implementations conforming to the System Interfaces volume of
IEEE Std 1003.1-2001 shall provide one or more locales that behave as described
in this chapter. The input to the utility is described in Locale Definition. The value that is used to specify a
locale when using environment variables shall be the string specified as the
name operand to the localedef utility when the locale
was created. The strings "C" and "POSIX" are reserved as
identifiers for the POSIX locale (see POSIX Locale).
When the value of a locale environment variable begins with a slash (
'/' ), it shall be interpreted as the pathname of the locale
definition; the type of file (regular, directory, and so on) used to store the
locale definition is implementation-defined. If the value does not begin with a
slash, the mechanism used to locate the locale is implementation-defined.

If different character sets are used by the locale categories, the results
achieved by an application utilizing these categories are undefined. Likewise,
if different codesets are used for the data being processed by interfaces whose
behavior is dependent on the current locale, or the codeset is different from
the codeset assumed when the locale was created, the result is also
undefined.

Applications can select the desired locale by invoking the setlocale() function (or
equivalent) with the appropriate value. If the function is invoked with an empty
string, such as:

setlocale(LC_ALL, "");

the value of the corresponding environment variable is used. If the
environment variable is unset or is set to the empty string, the implementation
shall set the appropriate environment as defined in Environment Variables.

7.2 POSIX Locale

Conforming systems shall provide a POSIX locale, also known as the C locale.
The behavior of standard utilities and functions in the POSIX locale shall be as
if the locale was defined via the localedef utility with input data
from the POSIX locale tables in Locale Definition.

The tables in Locale Definition describe the
characteristics and behavior of the POSIX locale for data consisting entirely of
characters from the portable character set and the control character set. For
other characters, the behavior is unspecified. For C-language programs, the
POSIX locale shall be the default locale when the setlocale() function is not
called.

The POSIX locale can be specified by assigning to the appropriate environment
variables the values "C" or "POSIX".

All implementations shall define a locale as the default locale, to be
invoked when no environment variables are set, or set to the empty string. This
default locale can be the POSIX locale or any other implementation-defined
locale. Some implementations may provide facilities for local installation
administrators to set the default locale, customizing it for each location.
IEEE Std 1003.1-2001 does not require such a facility.

7.3 Locale Definition

The capability to specify additional locales to those provided by an
implementation is optional, denoted by the _POSIX2_LOCALEDEF symbol. If the
option is not supported, only implementation-supplied locales are available.
Such locales shall be documented using the format specified in this section.

Locales can be described with the file format presented in this section. The
file format is that accepted by the localedef utility. For the
purposes of this section, the file is referred to as the "locale definition
file", but no locales shall be affected by this file unless it is processed by
localedef or some similar
mechanism. Any requirements in this section imposed upon the utility shall apply
to localedef or to any other
similar utility used to install locale information using the locale definition
file format described here.

The locale definition file shall contain one or more locale category source
definitions, and shall not contain more than one definition for the same locale
category. If the file contains source definitions for more than one category,
implementation-defined categories, if present, shall appear after the categories
defined by General. A category source definition
contains either the definition of a category or a copy directive. For a
description of the copy directive, see localedef. In the event that some
of the information for a locale category, as specified in this volume of
IEEE Std 1003.1-2001, is missing from the locale source definition, the behavior
of that category, if it is referenced, is unspecified.

A category source definition shall consist of a category header, a category
body, and a category trailer. A category header shall consist of the character
string naming of the category, beginning with the characters LC_ . The
category trailer shall consist of the string "END", followed by one or
more <blank>s and the string used in the corresponding category
header.

The category body shall consist of one or more lines of text. Each line shall
contain an identifier, optionally followed by one or more operands. Identifiers
shall be either keywords, identifying a particular locale element, or collating
elements. In addition to the keywords defined in this volume of
IEEE Std 1003.1-2001, the source can contain implementation-defined keywords.
Each keyword within a locale shall have a unique name (that is, two categories
cannot have a commonly-named keyword); no keyword shall start with the
characters LC_ . Identifiers shall be separated from the operands by one
or more <blank>s.

Operands shall be characters, collating elements, or strings of characters.
Strings shall be enclosed in double-quotes. Literal double-quotes within strings
shall be preceded by the <escape character>, described below. When
a keyword is followed by more than one operand, the operands shall be separated
by semicolons; <blank>s shall be allowed both before and after a
semicolon.

The first category header in the file can be preceded by a line modifying the
comment character. It shall have the following format, starting in column 1:

"comment_char %c\n", <comment character>

The comment character shall default to the number sign ( '#' ).
Blank lines and lines containing the <comment character> in the
first position shall be ignored.

The first category header in the file can be preceded by a line modifying the
escape character to be used in the file. It shall have the following format,
starting in column 1:

"escape_char %c\n", <escape character>

The escape character shall default to backslash, which is the character used
in all examples shown in this volume of IEEE Std 1003.1-2001.

A line can be continued by placing an escape character as the last character
on the line; this continuation character shall be discarded from the input.
Although the implementation need not accept any one portion of a continued line
with a length exceeding {LINE_MAX} bytes, it shall place no limits on the
accumulated length of the continued line. Comment lines shall not be continued
on a subsequent line using an escaped <newline>.

Individual characters, characters in strings, and collating elements shall be
represented using symbolic names, as defined below. In addition, characters can
be represented using the characters themselves or as octal, hexadecimal, or
decimal constants. When non-symbolic notation is used, the resultant locale
definitions are in many cases not portable between systems. The left angle
bracket ( '<' ) is a reserved symbol, denoting the start of a
symbolic name; when used to represent itself it shall be preceded by the escape
character. The following rules apply to character representation:

1. 
   

   A character can be represented via a symbolic name, enclosed within angle
   brackets '<' and '>'. The symbolic name, including the
   angle brackets, shall exactly match a symbolic name defined in the charmap file
   specified via the localedef
   -f option, and it shall be replaced by a character value determined from
   the value associated with the symbolic name in the charmap file. The use of a
   symbolic name not found in the charmap file shall constitute an error, unless
   the category is LC_CTYPE or LC_COLLATE , in which case it shall
   constitute a warning condition (see localedef for a description of
   actions resulting from errors and warnings). The specification of a symbolic
   name in a collating-element or collating-symbol section that
   duplicates a symbolic name in the charmap file (if present) shall be an error.
   Use of the escape character or a right angle bracket within a symbolic name is
   invalid unless the character is preceded by the escape character.

   
   

   For example:

   
   

   <c>;<c-cedilla> "<M><a><y>"
   
   

   
   
2. 
   

   A character in the portable character set can be represented by the character
   itself, in which case the value of the character is implementation-defined.
   (Implementations may allow other characters to be represented as themselves, but
   such locale definitions are not portable.) Within a string, the double-quote
   character, the escape character, and the right angle bracket character shall be
   escaped (preceded by the escape character) to be interpreted as the character
   itself. Outside strings, the characters:

   
   

   , ; < > escape_char
   

   
   

   shall be escaped to be interpreted as the character itself.

   
   

   For example:

   
   

   c "May"
   
   

   
   
3. 
   

   A character can be represented as an octal constant. An octal constant shall
   be specified as the escape character followed by two or three octal digits. Each
   constant shall represent a byte value. Multi-byte values can be represented by
   concatenated constants specified in byte order with the last constant specifying
   the least significant byte of the character.

   
   

   For example:

   
   

   \143;\347;\143\150 "\115\141\171"
   
   

   
   
4. 
   

   A character can be represented as a hexadecimal constant. A hexadecimal
   constant shall be specified as the escape character followed by an 'x'
   followed by two hexadecimal digits. Each constant shall represent a byte value.
   Multi-byte values can be represented by concatenated constants specified in byte
   order with the last constant specifying the least significant byte of the
   character.

   
   

   For example:

   
   

   \x63;\xe7;\x63\x68 "\x4d\x61\x79"
   
   

   
   
5. 
   

   A character can be represented as a decimal constant. A decimal constant
   shall be specified as the escape character followed by a 'd' followed
   by two or three decimal digits. Each constant represents a byte value.
   Multi-byte values can be represented by concatenated constants specified in byte
   order with the last constant specifying the least significant byte of the
   character.

   
   

   For example:

   
   

   \d99;\d231;\d99\d104 "\d77\d97\d121"
   
   

Implementations may accept single-digit octal, decimal, or hexadecimal
constants following the escape character. Only characters existing in the
character set for which the locale definition is created shall be specified,
whether using symbolic names, the characters themselves, or octal, decimal, or
hexadecimal constants. If a charmap file is present, only characters defined in
the charmap can be specified using octal, decimal, or hexadecimal constants.
Symbolic names not present in the charmap file can be specified and shall be
ignored, as specified under item 1 above.

7.3.1 LC_CTYPE

The LC_CTYPE category shall define character classification, case
conversion, and other character attributes. In addition, a series of characters
can be represented by three adjacent periods representing an ellipsis symbol (
"..." ). The ellipsis specification shall be interpreted as meaning
that all values between the values preceding and following it represent valid
characters. The ellipsis specification shall be valid only within a single
encoded character set; that is, within a group of characters of the same size.
An ellipsis shall be interpreted as including in the list all characters with an
encoded value higher than the encoded value of the character preceding the
ellipsis and lower than the encoded value of the character following the
ellipsis.

For example:

\x30;...;\x39;

includes in the character class all characters with encoded values between
the endpoints.

The following keywords shall be recognized. In the descriptions, the term
"automatically included" means that it shall not be an error either to include
or omit any of the referenced characters; the implementation provides them if
missing (even if the entire keyword is missing) and accepts them silently if
present. When the implementation automatically includes a missing character, it
shall have an encoded value dependent on the charmap file in effect (see the
description of the localedef
-f option); otherwise, it shall have a value derived from an
implementation-defined character mapping.

The character classes digit, xdigit, lower,
upper, and space have a set of automatically included characters.
These only need to be specified if the character values (that is, encoding)
differ from the implementation default values. It is not possible to define a
locale without these automatically included characters unless some
implementation extension is used to prevent their inclusion. Such a definition
would not be a proper superset of the C or POSIX locale and, thus, it might not
be possible for conforming applications to work properly.

In the POSIX locale, the 26 uppercase letters shall be included:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

In a locale definition file, no character specified for the keywords
cntrl, digit, punct, or space shall be specified.
The uppercase letters <A> to <Z>, as defined in Character Set Description File (the
portable character set), are automatically included in this class.

In the POSIX locale, the 26 lowercase letters shall be included:

a b c d e f g h i j k l m n o p q r s t u v w x y z

In a locale definition file, no character specified for the keywords
cntrl, digit, punct, or space shall be specified.
The lowercase letters <a> to <z> of the portable character set are
automatically included in this class.

In the POSIX locale, all characters in the classes upper and
lower shall be included.

In a locale definition file, no character specified for the keywords
cntrl, digit, punct, or space shall be specified.
Characters classified as either upper or lower are automatically
included in this class.

In the POSIX locale, only:

0 1 2 3 4 5 6 7 8 9

shall be included.

In a locale definition file, only the digits <zero>, <one>,
<two>, <three>, <four>, <five>, <six>,
<seven>, <eight>, and <nine> shall be specified, and in
contiguous ascending sequence by numerical value. The digits <zero> to
<nine> of the portable character set are automatically included in this
class.

In the POSIX locale, at a minimum, the <space>, <form-feed>,
<newline>, <carriage-return>, <tab>, and <vertical-tab>
shall be included.

In a locale definition file, no character specified for the keywords
upper, lower, alpha, digit, graph, or
xdigit shall be specified. The <space>, <form-feed>,
<newline>, <carriage-return>, <tab>, and <vertical-tab>
of the portable character set, and any characters included in the class
blank are automatically included in this class.

In the POSIX locale, no characters in classes alpha or print
shall be included.

In a locale definition file, no character specified for the keywords
upper, lower, alpha, digit, punct,
graph, print, or xdigit shall be specified.

In the POSIX locale, neither the <space> nor any characters in classes
alpha, digit, or cntrl shall be included.

In a locale definition file, no character specified for the keywords
upper, lower, alpha, digit, cntrl,
xdigit, or as the <space> shall be specified.

In the POSIX locale, all characters in classes alpha, digit,
and punct shall be included; no characters in class cntrl shall be
included.

In a locale definition file, characters specified for the keywords
upper, lower, alpha, digit, xdigit, and
punct are automatically included in this class. No character specified
for the keyword cntrl shall be specified.

In the POSIX locale, all characters in class graph shall be included;
no characters in class cntrl shall be included.

In a locale definition file, characters specified for the keywords
upper, lower, alpha, digit, xdigit,
punct, graph, and the <space> are automatically included in
this class. No character specified for the keyword cntrl shall be
specified.

In the POSIX locale, only:

0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

shall be included.

In a locale definition file, only the characters defined for the class
digit shall be specified, in contiguous ascending sequence by numerical
value, followed by one or more sets of six characters representing the
hexadecimal digits 10 to 15 inclusive, with each set in ascending order (for
example, <A>, <B>, <C>, <D>, <E>, <F>,
<a>, <b>, <c>, <d>, <e>, <f>). The digits
<zero> to <nine>, the uppercase letters <A> to <F>, and
the lowercase letters <a> to <f> of the portable character set are
automatically included in this class.

In the POSIX locale, only the <space> and <tab> shall be
included.

In a locale definition file, the <space> and <tab> are
automatically included in this class.

If a class name is defined by a charclass keyword, but no characters
are subsequently assigned to it, this is not an error; it represents a class
without any characters belonging to it.

The charclass-name can be used as the property argument to the
wctype() function, in regular
expression and shell pattern-matching bracket expressions, and by the tr command.

In the POSIX locale, at a minimum, the 26 lowercase characters:

a b c d e f g h i j k l m n o p q r s t u v w x y z

shall be mapped to the corresponding 26 uppercase characters:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

In a locale definition file, the operand shall consist of character pairs,
separated by semicolons. The characters in each character pair shall be
separated by a comma and the pair enclosed by parentheses. The first character
in each pair is the lowercase letter, the second the corresponding uppercase
letter. Only characters specified for the keywords lower and upper
shall be specified. The lowercase letters <a> to <z>, and their
corresponding uppercase letters <A> to <Z>, of the portable
character set are automatically included in this mapping, but only when the
toupper keyword is omitted from the locale definition.

In the POSIX locale, at a minimum, the 26 uppercase characters:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

shall be mapped to the corresponding 26 lowercase characters:

a b c d e f g h i j k l m n o p q r s t u v w x y z

In a locale definition file, the operand shall consist of character pairs,
separated by semicolons. The characters in each character pair shall be
separated by a comma and the pair enclosed by parentheses. The first character
in each pair is the uppercase letter, the second the corresponding lowercase
letter. Only characters specified for the keywords lower and upper
shall be specified. If the tolower keyword is omitted from the locale
definition, the mapping is the reverse mapping of the one specified for
toupper.

The following table shows the character class combinations allowed:

1. 
   

   Explanation of codes:

   
   A
   Automatically included; see text.
   -
   Permitted.
   x
   Mutually-exclusive.
   *
   See note 2.
   
2. 
   

   The <space>, which is part of the space and blank
   classes, cannot belong to punct or graph, but shall automatically
   belong to the print class. Other space or blank characters
   can be classified as any of punct, graph, or
   print.

LC_CTYPE Category in the POSIX Locale

The character classifications for the POSIX locale follow; the code listing
depicts the localedef input,
and the table represents the same information, sorted by character.

LC_CTYPE
# The following is the POSIX locale LC_CTYPE.
# "alpha" is by default "upper" and "lower"
# "alnum" is by definition "alpha" and "digit"
# "print" is by default "alnum", "punct", and the <space>
# "graph" is by default "alnum" and "punct"
#
upper <A>;<B>;<C>;<D>;<E>;<F>;<G>;<H>;<I>;<J>;<K>;<L>;<M>;\
 <N>;<O>;<P>;<Q>;<R>;<S>;<T>;<U>;<V>;<W>;<X>;<Y>;<Z>
#
lower <a>;<b>;<c>;<d>;<e>;<f>;<g>;<h>;<i>;<j>;<k>;<l>;<m>;\
 <n>;<o>;<p>;<q>;<r>;<s>;<t>;<u>;<v>;<w>;<x>;<y>;<z>
#
digit <zero>;<one>;<two>;<three>;<four>;<five>;<six>;\
 <seven>;<eight>;<nine>
#
space <tab>;<newline>;<vertical-tab>;<form-feed>;\
 <carriage-return>;<space>
#
cntrl <alert>;<backspace>;<tab>;<newline>;<vertical-tab>;\
 <form-feed>;<carriage-return>;\
 <NUL>;<SOH>;<STX>;<ETX>;<EOT>;<ENQ>;<ACK>;<SO>;\
 <SI>;<DLE>;<DC1>;<DC2>;<DC3>;<DC4>;<NAK>;<SYN>;\
 <ETB>;<CAN>;<EM>;<SUB>;<ESC>;<IS4>;<IS3>;<IS2>;\
 <IS1>;<DEL>
#
punct <exclamation-mark>;<quotation-mark>;<number-sign>;\
 <dollar-sign>;<percent-sign>;<ampersand>;<apostrophe>;\
 <left-parenthesis>;<right-parenthesis>;<asterisk>;\
 <plus-sign>;<comma>;<hyphen>;<period>;<slash>;\
 <colon>;<semicolon>;<less-than-sign>;<equals-sign>;\
 <greater-than-sign>;<question-mark>;<commercial-at>;\
 <left-square-bracket>;<backslash>;<right-square-bracket>;\
 <circumflex>;<underscore>;<grave-accent>;<left-curly-bracket>;\
 <vertical-line>;<right-curly-bracket>;<tilde>
#
xdigit <zero>;<one>;<two>;<three>;<four>;<five>;<six>;<seven>;\
 <eight>;<nine>;<A>;<B>;<C>;<D>;<E>;<F>;<a>;<b>;<c>;<d>;<e>;<f>
#
blank <space>;<tab>
#
toupper (<a>,<A>);(<b>,<B>);(<c>,<C>);(<d>,<D>);(<e>,<E>);\
 (<f>,<F>);(<g>,<G>);(<h>,<H>);(<i>,<I>);(<j>,<J>);\
 (<k>,<K>);(<l>,<L>);(<m>,<M>);(<n>,<N>);(<o>,<O>);\
 (<p>,<P>);(<q>,<Q>);(<r>,<R>);(<s>,<S>);(<t>,<T>);\
 (<u>,<U>);(<v>,<V>);(<w>,<W>);(<x>,<X>);(<y>,<Y>);(<z>,<Z>)
#
tolower (<A>,<a>);(<B>,<b>);(<C>,<c>);(<D>,<d>);(<E>,<e>);\
 (<F>,<f>);(<G>,<g>);(<H>,<h>);(<I>,<i>);(<J>,<j>);\
 (<K>,<k>);(<L>,<l>);(<M>,<m>);(<N>,<n>);(<O>,<o>);\
 (<P>,<p>);(<Q>,<q>);(<R>,<r>);(<S>,<s>);(<T>,<t>);\
 (<U>,<u>);(<V>,<v>);(<W>,<w>);(<X>,<x>);(<Y>,<y>);(<Z>,<z>)
END LC_CTYPE

7.3.2 LC_COLLATE

The LC_COLLATE category provides a collation sequence definition for
numerous utilities in the Shell and Utilities volume of IEEE Std 1003.1-2001 (
sort, uniq, and so on), regular expression
matching (see Regular Expressions),
and the strcoll(), strxfrm(), wcscoll(), and wcsxfrm() functions in the System
Interfaces volume of IEEE Std 1003.1-2001.

A collation sequence definition shall define the relative order between
collating elements (characters and multi-character collating elements) in the
locale. This order is expressed in terms of collation values; that is, by
assigning each element one or more collation values (also known as collation
weights). This does not imply that implementations shall assign such values, but
that ordering of strings using the resultant collation definition in the locale
behaves as if such assignment is done and used in the collation process. At
least the following capabilities are provided:

1. 
   

   Multi-character collating elements. Specification of multi-character
   collating elements (that is, sequences of two or more characters to be collated
   as an entity).

   
   
2. 
   

   User-defined ordering of collating elements. Each collating element
   shall be assigned a collation value defining its order in the character (or
   basic) collation sequence. This ordering is used by regular expressions and
   pattern matching and, unless collation weights are explicitly specified, also as
   the collation weight to be used in sorting.

   
   
3. 
   

   Multiple weights and equivalence classes. Collating elements can be
   assigned one or more (up to the limit {COLL_WEIGHTS_MAX}, as defined in <limits.h>) collating weights for use in
   sorting. The first weight is hereafter referred to as the primary weight.

   
   
4. 
   

   One-to-many mapping. A single character is mapped into a string of
   collating elements.

   
   
5. 
   

   Equivalence class definition. Two or more collating elements have the
   same collation value (primary weight).

   
   
6. 
   

   Ordering by weights. When two strings are compared to determine their
   relative order, the two strings are first broken up into a series of collating
   elements; the elements in each successive pair of elements are then compared
   according to the relative primary weights for the elements. If equal, and more
   than one weight has been assigned, then the pairs of collating elements are
   re-compared according to the relative subsequent weights, until either a pair of
   collating elements compare unequal or the weights are exhausted.

The following keywords shall be recognized in a collation sequence
definition. They are described in detail in the following sections.

The collating-element Keyword

In addition to the collating elements in the character set, the
collating-element keyword can be used to define multi-character collating
elements. The syntax is as follows:

"collating-element %s from \"%s\"\n", <collating-symbol>, <string>

The <collating-symbol> operand shall be a symbolic name,
enclosed between angle brackets ( '<' and '>' ), and
shall not duplicate any symbolic name in the current charmap file (if any), or
any other symbolic name defined in this collation definition. The string operand
is a string of two or more characters that collates as an entity. A
<collating-element> defined via this keyword is only recognized
with the LC_COLLATE category.

For example:

collating-element <ch> from "<c><h>"
collating-element <e-acute> from "<acute><e>"
collating-element <ll> from "ll"

The collating-symbol Keyword

This keyword shall be used to define symbols for use in collation sequence
statements; that is, between the order_start and the order_end
keywords. The syntax is as follows:

"collating-symbol %s\n", <collating-symbol>

The <collating-symbol> shall be a symbolic name, enclosed
between angle brackets ( '<' and '>' ), and shall not
duplicate any symbolic name in the current charmap file (if any), or any other
symbolic name defined in this collation definition. A
<collating-symbol> defined via this keyword is only recognized
within the LC_COLLATE category.

For example:

collating-symbol <UPPER_CASE>
collating-symbol <HIGH>

The collating-symbol keyword defines a symbolic name that can be
associated with a relative position in the character order sequence. While such
a symbolic name does not represent any collating element, it can be used as a
weight.

The order_start Keyword

The order_start keyword shall precede collation order entries and also
define the number of weights for this collation sequence definition and other
collation rules. The syntax is as follows:

"order_start %s;%s;...;%s\n", <sort-rules>, <sort-rules> ...

The operands to the order_start keyword are optional. If present, the
operands define rules to be applied when strings are compared. The number of
operands define how many weights each element is assigned; if no operands are
present, one forward operand is assumed. If present, the first operand
defines rules to be applied when comparing strings using the first (primary)
weight; the second when comparing strings using the second weight, and so on.
Operands shall be separated by semicolons ( ';' ). Each operand shall
consist of one or more collation directives, separated by commas ( ','
). If the number of operands exceeds the {COLL_WEIGHTS_MAX} limit, the utility
shall issue a warning message. The following directives shall be supported:

The directives forward and backward are mutually-exclusive.

If no operands are specified, a single forward operand shall be
assumed.

For example:

order_start forward;backward

Collation Order

The order_start keyword shall be followed by collating identifier
entries. The syntax for the collating element entries is as follows:

"%s %s;%s;...;%s\n", <collating-identifier>, <weight>, <weight>, ...

Each collating-identifier shall consist of either a character (in any
of the forms defined in Locale Definition), a
<collating-element>, a <collating-symbol>, an
ellipsis, or the special symbol UNDEFINED. The order in which collating
elements are specified determines the character order sequence, such that each
collating element shall compare less than the elements following it.

A <collating-element> shall be used to specify multi-character
collating elements, and indicates that the character sequence specified via the
<collating-element> is to be collated as a unit and in the relative
order specified by its place.

A <collating-symbol> can be used to define a position in the
relative order for use in weights. No weights shall be specified with a
<collating-symbol>.

The ellipsis symbol specifies that a sequence of characters shall collate
according to their encoded character values. It shall be interpreted as
indicating that all characters with a coded character set value higher than the
value of the character in the preceding line, and lower than the coded character
set value for the character in the following line, in the current coded
character set, shall be placed in the character collation order between the
previous and the following character in ascending order according to their coded
character set values. An initial ellipsis shall be interpreted as if the
preceding line specified the NUL character, and a trailing ellipsis as if the
following line specified the highest coded character set value in the current
coded character set. An ellipsis shall be treated as invalid if the preceding or
following lines do not specify characters in the current coded character set.
The use of the ellipsis symbol ties the definition to a specific coded character
set and may preclude the definition from being portable between
implementations.

The symbol UNDEFINED shall be interpreted as including all coded
character set values not specified explicitly or via the ellipsis symbol. Such
characters shall be inserted in the character collation order at the point
indicated by the symbol, and in ascending order according to their coded
character set values. If no UNDEFINED symbol is specified, and the
current coded character set contains characters not specified in this section,
the utility shall issue a warning message and place such characters at the end
of the character collation order.

The optional operands for each collation-element shall be used to define the
primary, secondary, or subsequent weights for the collating element. The first
operand specifies the relative primary weight, the second the relative secondary
weight, and so on. Two or more collation-elements can be assigned the same
weight; they belong to the same "equivalence class" if they have the same
primary weight. Collation shall behave as if, for each weight level, elements
subject to IGNORE are removed, unless the position collation
directive is specified for the corresponding level with the order_start
keyword. Then each successive pair of elements shall be compared according to
the relative weights for the elements. If the two strings compare equal, the
process shall be repeated for the next weight level, up to the limit
{COLL_WEIGHTS_MAX}.

Weights shall be expressed as characters (in any of the forms specified in Locale Definition), <collating-symbol>s,
<collating-element>s, an ellipsis, or the special symbol
IGNORE. A single character, a <collating-symbol>, or a
<collating-element> shall represent the relative position in the
character collating sequence of the character or symbol, rather than the
character or characters themselves. Thus, rather than assigning absolute values
to weights, a particular weight is expressed using the relative order value
assigned to a collating element based on its order in the character collation
sequence.

One-to-many mapping is indicated by specifying two or more concatenated
characters or symbolic names. For example, if the <eszet> is given the
string "<s><s>" as a weight, comparisons are performed as
if all occurrences of the <eszet> are replaced by
"<s><s>" (assuming that "<s>" has the
collating weight "<s>" ). If it is necessary to define
<eszet> and "<s><s>" as an equivalence class, then a
collating element must be defined for the string "ss".

All characters specified via an ellipsis shall by default be assigned unique
weights, equal to the relative order of characters. Characters specified via an
explicit or implicit UNDEFINED special symbol shall by default be
assigned the same primary weight (that is, they belong to the same equivalence
class). An ellipsis symbol as a weight shall be interpreted to mean that each
character in the sequence shall have unique weights, equal to the relative order
of their character in the character collation sequence. The use of the ellipsis
as a weight shall be treated as an error if the collating element is neither an
ellipsis nor the special symbol UNDEFINED.

The special keyword IGNORE as a weight shall indicate that when
strings are compared using the weights at the level where IGNORE is
specified, the collating element shall be ignored; that is, as if the string did
not contain the collating element. In regular expressions and pattern matching,
all characters that are subject to IGNORE in their primary weight form an
equivalence class.

An empty operand shall be interpreted as the collating element itself.

For example, the order statement:

<a> <a>;<a>

is equal to:

<a>

An ellipsis can be used as an operand if the collating element was an
ellipsis, and shall be interpreted as the value of each character defined by the
ellipsis.

The collation order as defined in this section affects the interpretation of
bracket expressions in regular expressions (see RE Bracket Expression).

For example:

order_start forward;backward
UNDEFINED IGNORE;IGNORE
<LOW>
<space> <LOW>;<space>
... <LOW>;...
<a> <a>;<a>
<a-acute> <a>;<a-acute>
<a-grave> <a>;<a-grave>
<A> <a>;<A>
<A-acute> <a>;<A-acute>
<A-grave> <a>;<A-grave>
<ch> <ch>;<ch>
<Ch> <ch>;<Ch>
<s> <s>;<s>
<eszet> "<s><s>";"<eszet><eszet>"
order_end

This example is interpreted as follows:

1. 
   

   The UNDEFINED means that all characters not specified in this
   definition (explicitly or via the ellipsis) shall be ignored for collation
   purposes.

   
   
2. 
   

   All characters between <space> and 'a' shall have the same
   primary equivalence class and individual secondary weights based on their
   ordinal encoded values.

   
   
3. 
   

   All characters based on the uppercase or lowercase character 'a'
   belong to the same primary equivalence class.

   
   
4. 
   

   The multi-character collating element <ch> is represented by the
   collating symbol <ch> and belongs to the same primary equivalence class as
   the multi-character collating element <Ch>.

The order_end Keyword

The collating order entries shall be terminated with an order_end
keyword.

LC_COLLATE Category in the POSIX Locale

The collation sequence definition of the POSIX locale follows; the code
listing depicts the localedef
input.

LC_COLLATE
# This is the POSIX locale definition for the LC_COLLATE category.
# The order is the same as in the ASCII codeset.
order_start forward
<NUL>
<SOH>
<STX>
<ETX>
<EOT>
<ENQ>
<ACK>
<alert>
<backspace>
<tab>
<newline>
<vertical-tab>
<form-feed>
<carriage-return>
<SO>
<SI>
<DLE>
<DC1>
<DC2>
<DC3>
<DC4>
<NAK>
<SYN>
<ETB>
<CAN>
<EM>
<SUB>
<ESC>
<IS4>
<IS3>
<IS2>
<IS1>
<space>
<exclamation-mark>
<quotation-mark>
<number-sign>
<dollar-sign>
<percent-sign>
<ampersand>
<apostrophe>
<left-parenthesis>
<right-parenthesis>
<asterisk>
<plus-sign>
<comma>
<hyphen>
<period>
<slash>
<zero>
<one>
<two>
<three>
<four>
<five>
<six>
<seven>
<eight>
<nine>
<colon>
<semicolon>
<less-than-sign>
<equals-sign>
<greater-than-sign>
<question-mark>
<commercial-at>
<A>
<B>
<C>
<D>
<E>
<F>
<G>
<H>
<I>
<J>
<K>
<L>
<M>
<N>
<O>
<P>
<Q>
<R>
<S>
<T>
<U>
<V>
<W>
<X>
<Y>
<Z>
<left-square-bracket>
<backslash>
<right-square-bracket>
<circumflex>
<underscore>
<grave-accent>
<a>
<b>
<c>
<d>
<e>
<f>
<g>
<h>
<i>
<j>
<k>
<l>
<m>
<n>
<o>
<p>
<q>
<r>
<s>
<t>
<u>
<v>
<w>
<x>
<y>
<z>
<left-curly-bracket>
<vertical-line>
<right-curly-bracket>
<tilde>
<DEL>
order_end
#
END LC_COLLATE

7.3.3 LC_MONETARY

The LC_MONETARY category shall define the rules and symbols that are
used to format monetary numeric information.

This information is available through the localeconv() function ^[XSI]  and is used by the strfmon() function.

^[XSI] Some of the information is
also available in an alternative form via the nl_langinfo() function (see
CRNCYSTR in <langinfo.h>).

The following items are defined in this category of the locale. The item
names are the keywords recognized by the localedef utility when defining a
locale. They are also similar to the member names of the lconv structure
defined in <locale.h>; see <locale.h> for the exact symbols in the
header. The localeconv()
function returns {CHAR_MAX} for unspecified integer items and the empty string (
"" ) for unspecified or size zero string items.

In a locale definition file, the operands are strings, formatted as indicated
by the grammar in Locale Definition Grammar. For some
keywords, the strings can contain only integers. Keywords that are not provided,
string values set to the empty string ( "" ), or integer keywords set
to -1, are used to indicate that the value is not available in the locale. The
following keywords shall be recognized:

The values of p_sep_by_space, n_sep_by_space,
int_p_sep_by_space, and int_n_sep_by_space are interpreted
according to the following:

LC_MONETARY Category in the POSIX Locale

The monetary formatting definitions for the POSIX locale follow; the code
listing depicting the localedef
input, the table representing the same information with the addition of localeconv() ^[XSI]  and nl_langinfo() formats. All values are
unspecified in the POSIX locale.

LC_MONETARY
# This is the POSIX locale definition for
# the LC_MONETARY category.
#
int_curr_symbol ""
currency_symbol ""
mon_decimal_point ""
mon_thousands_sep ""
mon_grouping -1
positive_sign ""
negative_sign ""
int_frac_digits -1
frac_digits -1
p_cs_precedes -1
p_sep_by_space -1
n_cs_precedes -1
n_sep_by_space -1
p_sign_posn -1
n_sign_posn -1
int_p_cs_precedes -1
int_p_sep_by_space -1
int_n_cs_precedes -1
int_n_sep_by_space -1
int_p_sign_posn -1
int_n_sign_posn -1
#
END LC_MONETARY

^[XSI] In the preceding table, the
langinfo Constant column represents an XSI-conformant extension. The entry N/A indicates
that the value is not available in the POSIX locale.

7.3.4 LC_NUMERIC

The LC_NUMERIC category shall define the rules and symbols that are
used to format non-monetary numeric information. This information is available
through the localeconv()
function.

^[XSI] Some of the information is
also available in an alternative form via the nl_langinfo() function.

The following items are defined in this category of the locale. The item
names are the keywords recognized by the localedef utility when defining a
locale. They are also similar to the member names of the lconv structure
defined in <locale.h>; see <locale.h> for the exact symbols in the
header. The localeconv()
function returns {CHAR_MAX} for unspecified integer items and the empty string (
"" ) for unspecified or size zero string items.

In a locale definition file, the operands are strings, formatted as indicated
by the grammar in Locale Definition Grammar. For some
keywords, the strings can only contain integers. Keywords that are not provided,
string values set to the empty string ( "" ), or integer keywords set
to -1, shall be used to indicate that the value is not available in the locale.
The following keywords shall be recognized:

LC_NUMERIC Category in the POSIX Locale

The non-monetary numeric formatting definitions for the POSIX locale follow;
the code listing depicting the localedef input, the table
representing the same information with the addition of localeconv() values, ^[XSI]  and nl_langinfo() constants.

LC_NUMERIC
# This is the POSIX locale definition for
# the LC_NUMERIC category.
#
decimal_point "<period>"
thousands_sep ""
grouping -1
#
END LC_NUMERIC

^[XSI] In the preceding table, the
langinfo Constant column represents an XSI-conforming extension. The entry N/A indicates
that the value is not available in the POSIX locale.

7.3.5 LC_TIME

The LC_TIME category shall define the interpretation of the conversion
specifications supported by the date
utility and shall affect the behavior of the strftime(), wcsftime(), strptime(), ^[XSI]  and nl_langinfo()  functions. Since the interfaces
for C-language access and locale definition differ significantly, they are
described separately.

LC_TIME Locale Definition

In a locale definition, the following mandatory keywords shall be
recognized:

direction:offset:start_date:end_date:era_name:era_format

according to the definitions below. There can be as many era description
segments as are necessary to describe the different eras.

LC_TIME C-Language Access

^[XSI] This section describes
extensions to access information in the LC_TIME category using the nl_langinfo() function. This
functionality is dependent on support of the XSI extension (and the rest of this
section is not further marked for this option).

The following constants used to identify items of langinfo data can be
used as arguments to the nl_langinfo() function to access
information in the LC_TIME category. These constants are defined in the
<langinfo.h> header.

direction:offset:start_date:end_date:era_name:era_format

according to the definitions below. There can be as many era description
segments as are necessary to describe the different eras. Era description
segments are separated by semicolons.

LC_TIME Category in the POSIX Locale

The LC_TIME category definition of the POSIX locale follows; the code
listing depicts the localedef
input; the table represents the same information with the addition of localedef keywords, conversion
specifiers used by the date utility
and the strftime(), wcsftime(), and strptime() functions, ^[XSI]  and nl_langinfo() constants.

LC_TIME
# This is the POSIX locale definition for
# the LC_TIME category.
#
# Abbreviated weekday names (%a)
abday "<S><u><n>";"<M><o><n>";"<T><u><e>";"<W><e><d>";\
 "<T><h><u>";"<F><r><i>";"<S><a><t>"
#
# Full weekday names (%A)
day "<S><u><n><d><a><y>";"<M><o><n><d><a><y>";\
 "<T><u><e><s><d><a><y>";"<W><e><d><n><e><s><d><a><y>";\
 "<T><h><u><r><s><d><a><y>";"<F><r><i><d><a><y>";\
 "<S><a><t><u><r><d><a><y>"
#
# Abbreviated month names (%b)
abmon "<J><a><n>";"<F><e><b>";"<M><a><r>";\
 "<A><p><r>";"<M><a><y>";"<J><u><n>";\
 "<J><u><l>";"<A><u><g>";"<S><e><p>";\
 "<O><c><t>";"<N><o><v>";"<D><e><c>"
#
# Full month names (%B)
mon "<J><a><n><u><a><r><y>";"<F><e><b><r><u><a><r><y>";\
 "<M><a><r><c><h>";"<A><p><r><i><l>";\
 "<M><a><y>";"<J><u><n><e>";\
 "<J><u><l><y>";"<A><u><g><u><s><t>";\
 "<S><e><p><t><e><m><b><e><r>";"<O><c><t><o><b><e><r>";\
 "<N><o><v><e><m><b><e><r>";"<D><e><c><e><m><b><e><r>"
#
# Equivalent of AM/PM (%p) "AM";"PM"
am_pm "<A><M>";"<P><M>"
#
# Appropriate date and time representation (%c)
# "%a %b %e %H:%M:%S %Y"
d_t_fmt "<percent-sign><a><space><percent-sign><b>\
<space><percent-sign><e><space><percent-sign><H>\
<colon><percent-sign><M><colon><percent-sign><S>\
<space><percent-sign><Y>"
#
# Appropriate date representation (%x) "%m/%d/%y"
d_fmt "<percent-sign><m><slash><percent-sign><d>\
<slash><percent-sign><y>"
#
# Appropriate time representation (%X) "%H:%M:%S"
t_fmt "<percent-sign><H><colon><percent-sign><M>\
<colon><percent-sign><S>"
#
# Appropriate 12-hour time representation (%r) "%I:%M:%S %p"
t_fmt_ampm "<percent-sign><I><colon><percent-sign><M><colon>\
<percent-sign><S><space><percent_sign><p>"
#
END LC_TIME

^[XSI] In the preceding table, the
langinfo Constant column represents an XSI-conformant extension.

The entry N/A indicates the value is not available in the POSIX locale.

7.3.6 LC_MESSAGES

The LC_MESSAGES category shall define the format and values used by
various utilities for affirmative and negative responses. ^[XSI] This information is
available through the nl_langinfo() function.

^[XSI] The message catalog used by
the standard utilities and selected by the catopen() function shall be
determined by the setting of NLSPATH ; see Environment Variables. The
LC_MESSAGES category can be specified as part of an NLSPATH
substitution field.

The following keywords shall be recognized as part of the locale definition
file.

LC_MESSAGES Category in the POSIX Locale

The format and values for affirmative and negative responses of the POSIX
locale follow; the code listing depicting the localedef input, the table
representing the same information ^[XSI]  with the addition of nl_langinfo() constants.

LC_MESSAGES
# This is the POSIX locale definition for
# the LC_MESSAGES category.
#
yesexpr "<circumflex><left-square-bracket><y><Y><right-square-bracket>"
#
noexpr "<circumflex><left-square-bracket><n><N><right-square-bracket>"
#
END LC_MESSAGES

^[XSI] In the preceding table, the
langinfo Constant column represents an XSI-conformant extension.

7.4 Locale Definition Grammar

The grammar and lexical conventions in this section shall together describe
the syntax for the locale definition source. The general conventions for this
style of grammar are described in the Shell and Utilities volume of
IEEE Std 1003.1-2001, Section
1.10, Grammar Conventions. The grammar shall take precedence over the text
in this chapter.

7.4.1 Locale Lexical Conventions

The lexical conventions for the locale definition grammar are described in
this section.

The following tokens shall be processed (in addition to those string
constants shown in the grammar):

7.4.2 Locale Grammar

This section presents the grammar for the locale definition.

%token LOC_NAME
%token CHAR
%token NUMBER
%token COLLSYMBOL COLLELEMENT
%token CHARSYMBOL OCTAL_CHAR HEX_CHAR DECIMAL_CHAR
%token ELLIPSIS
%token EXTENDED_REG_EXP
%token EOL


%start locale_definition


%%


locale_definition : global_statements locale_categories
 | locale_categories
 ;


global_statements : global_statements symbol_redefine
 | symbol_redefine
 ;


symbol_redefine : 'escape_char' CHAR EOL
 | 'comment_char' CHAR EOL
 ;


locale_categories : locale_categories locale_category
 | locale_category
 ;


locale_category : lc_ctype | lc_collate | lc_messages
 | lc_monetary | lc_numeric | lc_time
 ;


/* The following grammar rules are common to all categories */


char_list : char_list char_symbol
 | char_symbol
 ;


char_symbol : CHAR | CHARSYMBOL
 | OCTAL_CHAR | HEX_CHAR | DECIMAL_CHAR
 ;


elem_list : elem_list char_symbol
 | elem_list COLLSYMBOL
 | elem_list COLLELEMENT
 | char_symbol
 | COLLSYMBOL
 | COLLELEMENT
 ;


symb_list : symb_list COLLSYMBOL
 | COLLSYMBOL
 ;


locale_name : LOC_NAME
 | '"' LOC_NAME '"'
 ;


/* The following is the LC_CTYPE category grammar */


lc_ctype : ctype_hdr ctype_keywords ctype_tlr
 | ctype_hdr 'copy' locale_name EOL ctype_tlr
 ;


ctype_hdr : 'LC_CTYPE' EOL
 ;


ctype_keywords : ctype_keywords ctype_keyword
 | ctype_keyword
 ;


ctype_keyword : charclass_keyword charclass_list EOL
 | charconv_keyword charconv_list EOL
 | 'charclass' charclass_namelist EOL
 ;


charclass_namelist : charclass_namelist ';' CHARCLASS
 | CHARCLASS
 ;


charclass_keyword : 'upper' | 'lower' | 'alpha' | 'digit'
 | 'punct' | 'xdigit' | 'space' | 'print'
 | 'graph' | 'blank' | 'cntrl' | 'alnum'
 | CHARCLASS
 ;


charclass_list : charclass_list ';' char_symbol
 | charclass_list ';' ELLIPSIS ';' char_symbol
 | char_symbol
 ;


charconv_keyword : 'toupper'
 | 'tolower'
 ;


charconv_list : charconv_list ';' charconv_entry
 | charconv_entry
 ;


charconv_entry : '(' char_symbol ',' char_symbol ')'
 ;


ctype_tlr : 'END' 'LC_CTYPE' EOL
 ;


/* The following is the LC_COLLATE category grammar */


lc_collate : collate_hdr collate_keywords collate_tlr
 | collate_hdr 'copy' locale_name EOL collate_tlr
 ;


collate_hdr : 'LC_COLLATE' EOL
 ;


collate_keywords : order_statements
 | opt_statements order_statements
 ;


opt_statements : opt_statements collating_symbols
 | opt_statements collating_elements
 | collating_symbols
 | collating_elements
 ;


collating_symbols : 'collating-symbol' COLLSYMBOL EOL
 ;


collating_elements : 'collating-element' COLLELEMENT
 | 'from' '"' elem_list '"' EOL
 ;


order_statements : order_start collation_order order_end
 ;


order_start : 'order_start' EOL
 | 'order_start' order_opts EOL
 ;


order_opts : order_opts ';' order_opt
 | order_opt
 ;


order_opt : order_opt ',' opt_word
 | opt_word
 ;


opt_word : 'forward' | 'backward' | 'position'
 ;


collation_order : collation_order collation_entry
 | collation_entry
 ;


collation_entry : COLLSYMBOL EOL
 | collation_element weight_list EOL
 | collation_element EOL
 ;


collation_element : char_symbol
 | COLLELEMENT
 | ELLIPSIS
 | 'UNDEFINED'
 ;


weight_list : weight_list ';' weight_symbol
 | weight_list ';'
 | weight_symbol
 ;


weight_symbol : /* empty */
 | char_symbol
 | COLLSYMBOL
 | '"' elem_list '"'
 | '"' symb_list '"'
 | ELLIPSIS
 | 'IGNORE'
 ;


order_end : 'order_end' EOL
 ;


collate_tlr : 'END' 'LC_COLLATE' EOL
 ;


/* The following is the LC_MESSAGES category grammar */


lc_messages : messages_hdr messages_keywords messages_tlr
 | messages_hdr 'copy' locale_name EOL messages_tlr
 ;


messages_hdr : 'LC_MESSAGES' EOL
 ;


messages_keywords : messages_keywords messages_keyword
 | messages_keyword
 ;


messages_keyword : 'yesexpr' '"' EXTENDED_REG_EXP '"' EOL
 | 'noexpr' '"' EXTENDED_REG_EXP '"' EOL
 ;


messages_tlr : 'END' 'LC_MESSAGES' EOL
 ;


/* The following is the LC_MONETARY category grammar */


lc_monetary : monetary_hdr monetary_keywords monetary_tlr
 | monetary_hdr 'copy' locale_name EOL monetary_tlr
 ;


monetary_hdr : 'LC_MONETARY' EOL
 ;


monetary_keywords : monetary_keywords monetary_keyword
 | monetary_keyword
 ;


monetary_keyword : mon_keyword_string mon_string EOL
 | mon_keyword_char NUMBER EOL
 | mon_keyword_char '-1' EOL
 | mon_keyword_grouping mon_group_list EOL
 ;


mon_keyword_string : 'int_curr_symbol' | 'currency_symbol'
 | 'mon_decimal_point' | 'mon_thousands_sep'
 | 'positive_sign' | 'negative_sign'
 ;


mon_string : '"' char_list '"'
 | '""'
 ;


mon_keyword_char : 'int_frac_digits' | 'frac_digits'
 | 'p_cs_precedes' | 'p_sep_by_space'
 | 'n_cs_precedes' | 'n_sep_by_space'
 | 'p_sign_posn' | 'n_sign_posn'
 | 'int_p_cs_precedes' | 'int_p_sep_by_space'
 | 'int_n_cs_precedes' | 'int_n_sep_by_space'
 | 'int_p_sign_posn' | 'int_n_sign_posn'
 ;


mon_keyword_grouping : 'mon_grouping'
 ;


mon_group_list : NUMBER
 | mon_group_list ';' NUMBER
 ;


monetary_tlr : 'END' 'LC_MONETARY' EOL
 ;


/* The following is the LC_NUMERIC category grammar */


lc_numeric : numeric_hdr numeric_keywords numeric_tlr
 | numeric_hdr 'copy' locale_name EOL numeric_tlr
 ;


numeric_hdr : 'LC_NUMERIC' EOL
 ;


numeric_keywords : numeric_keywords numeric_keyword
 | numeric_keyword
 ;


numeric_keyword : num_keyword_string num_string EOL
 | num_keyword_grouping num_group_list EOL
 ;


num_keyword_string : 'decimal_point'
 | 'thousands_sep'
 ;


num_string : '"' char_list '"'
 | '""'
 ;


num_keyword_grouping: 'grouping'
 ;


num_group_list : NUMBER
 | num_group_list ';' NUMBER
 ;


numeric_tlr : 'END' 'LC_NUMERIC' EOL
 ;


/* The following is the LC_TIME category grammar */


lc_time : time_hdr time_keywords time_tlr
 | time_hdr 'copy' locale_name EOL time_tlr
 ;


time_hdr : 'LC_TIME' EOL
 ;


time_keywords : time_keywords time_keyword
 | time_keyword
 ;


time_keyword : time_keyword_name time_list EOL
 | time_keyword_fmt time_string EOL
 | time_keyword_opt time_list EOL
 ;


time_keyword_name : 'abday' | 'day' | 'abmon' | 'mon'
 ;


time_keyword_fmt : 'd_t_fmt' | 'd_fmt' | 't_fmt'
 | 'am_pm' | 't_fmt_ampm'
 ;


time_keyword_opt : 'era' | 'era_d_fmt' | 'era_t_fmt'
 | 'era_d_t_fmt' | 'alt_digits'
 ;


time_list : time_list ';' time_string
 | time_string
 ;


time_string : '"' char_list '"'
 ;


time_tlr : 'END' 'LC_TIME' EOL
 ;