|Version||Unicode 5.0.0 Draft|
|Authors||Mark Davis (email@example.com)|
This annex describes specifications for recommended defaults for the use of Unicode in the definitions of identifiers and in pattern-based syntax. It also supplies guidelines for use of normalization with identifiers.
This document is a proposed update of a previously approved Unicode Standard Annex. Publication does not imply endorsement by the Unicode Consortium. This is a draft document which may be updated, replaced, or superseded by other documents at any time. This is not a stable document; it is inappropriate to cite this document as other than a work in progress.
A Unicode Standard Annex (UAX) forms an integral part of the Unicode Standard, but is published online as a separate document. The Unicode Standard may require conformance to normative content in a Unicode Standard Annex, if so specified in the Conformance chapter of that version of the Unicode Standard. The version number of a UAX document corresponds to the version of the Unicode Standard of which it forms a part.
Please submit corrigenda and other comments with the online reporting form [Feedback]. Related information that is useful in understanding this annex is found in Unicode Standard Annex #41, “Common References for Unicode Standard Annexes.” For the latest version of the Unicode Standard see [Unicode]. For a list of current Unicode Technical Reports see [Reports]. For more information about versions of the Unicode Standard, see [Versions].
- 1 Introduction
- 1.1 Conformance
- 2 Default Identifier Syntax
- 3 Alternative Identifier Syntax
- 4 Pattern Syntax
- 5 Normalization and Case
A common task facing an implementer of the Unicode Standard is the provision of a parsing and/or lexing engine for identifiers, such as programming language variables or domain names. To assist in the standard treatment of identifiers in Unicode character-based parsers and lexical analyzers, a set of specifications is provided here as a recommended default for the definition of identifier syntax. These guidelines are no more complex than current rules in the common programming languages, except that they include more characters of different types. This annex also provides guidelines for the user of normalization and case-insensitivity with identifiers, expanding on a section that was originally in Unicode Standard Annex #15, “Unicode Normalization Forms” [UAX15].
The specification in this annex provide a definition of identifiers that is guaranteed to be backward compatible with each successive release of Unicode, but also allows any appropriate new Unicode characters to become available in identifiers. In addition, Unicode character properties for stable pattern syntax are provided. The resulting pattern syntax is stable over future versions of the Unicode Standard. These property can either be used alone or in conjunction with the identifier characters.
Figure 1 shows the disjoint categories of code points defined in this annex (the sizes of the boxes are not to scale):
|Unassigned Code Points|
The set consisting of the union of ID_Start and ID Nonstart characters are known as Identifier Characters, and have the property ID_Continue. The ID Nonstart set is defined as the difference ID_Continue - ID_Start. While lexical rules are traditionally expressed in terms of the latter, the discussion here is simplified by referring to disjoint categories.
Stability. There are certain features that developers can depend on for stability:
In successive versions of Unicode, the only allowed changes of characters from one of the above classes to another are those listed with a + sign in Table 1.
|ID_Start||ID Nonstart||Other Assigned|
The Unicode Consortium has formally adopted a stability policy on identifiers. For more information, see [Stability].
Programming Languages. Each programming language standard has its own identifier syntax; different programming languages have different conventions for the use of certain characters such as $, @, #, or _ in identifiers. To extend such a syntax to cover the full behavior of a Unicode implementation, implementers may combine those specific rules with the syntax and properties provided here.
That is, each programming language can define its identifier syntax as relative to the Unicode identifier syntax, such as saying that identifiers are defined by the Unicode properties, with the addition of “$”. By addition or subtraction of a small set of language specific characters, a programming language standard can easily track a growing repertoire of Unicode characters in a compatible way.
Similarly, each programming language can define its own whitespace characters or syntax characters relative to the Unicode Pattern_White_Space or Pattern_Syntax characters, with some specified set of additions or subtractions.
Systems that want to extend identifiers so as to encompass words used in natural languages may add characters identified in Section 4, Word Boundaries of [UAX29] with the property values Katakana, ALetter, and MidLetter, plus characters described in the notes at the end of that section.
To preserve the disjoint nature of the categories illustrated in Figure 1, any character added to one of the categories must be subtracted from the others.
Note: In many cases there are important security implications that may require additional constraints on identifiers. For more information, see [UTR36].
The following describes the possible ways that an implementation can claim conformance to this specification.
|UAX31-C1.||An implementation claiming conformance to this specification at any
Level shall identify the version of this specification and the version of the Unicode
|UAX31-C2.||An implementation claiming conformance to Level 1 of this specification shall describe which of the following it observes:|
The formal syntax provided here captures the general intent that an identifier consists of a string of characters beginning with a letter or an ideograph, and following with any number of letters, ideographs, digits, or underscores. It provides a definition of identifiers that is guaranteed to be backward compatible with each successive release of Unicode, but also adds any appropriate new Unicode characters.
<identifier> := <ID_Start> <ID_Continue>*
Identifiers are defined by the sets of lexical classes defined as properties in the Unicode Character Database. These properties are shown in Table 2.
|Properties||Alternates||General Description of Coverage|
||Characters having the Unicode General_Category of: Uppercase letters, lowercase letters, titlecase letters, modifier letters, other letters, letter numbers, plus stability extensions. Note that “other letters” includes ideographs.|
||All of the above, plus characters having the
Unicode General_Category of: nonspacing marks (Mn), spacing combining marks
(Mc), decimal nubmer (Nd), connector punctuations (Pc), plus stability
extensions. These are also known simply as Identifier Characters, because they are
a superset of the
The innovations in the identifier syntax to cover the Unicode Standard include the following:
Combining marks are accounted for in identifier syntax: a composed character sequence consisting of a base character followed by any number of combining marks is valid in an identifier. Combining marks are required in the representation of many languages, and the conformance rules in Chapter 3, Conformance of [Unicode] require the interpretation of canonical-equivalent character sequences.
Enclosing combining marks (such as
U+20DD..U+20E0) are excluded from the
definition of the
ID_Continue, because the composite characters that result from their
composition with letters are themselves not normally considered valid constituents of these
Certain Unicode characters are used to control joining behavior, bidirectional ordering control, and alternative formats for display. These have the General_Category value of Cf. Unlike space characters or other delimiters, they do not indicate word, line, or other unit boundaries.
While it is possible to ignore these characters in determining identifiers, the recommendation is to not ignore them, and not permit them in identifiers except in special cases. This is because of the possibility for confusion between two visually identical strings; see [UTR36]. Some possible exceptions are the ZWJ and ZWNJ in certain contexts, such as between certain characters in Indic words.
Specific identifier syntaxes can be treated as tailorings (or
profiles) of the generic syntax based on character properties. For example, SQL
identifiers allow an underscore as an identifier start, but not as an identifier start; C
identifiers allow an underscore as either an identifier continue or an identifier start. Specific
languages may also want to exclude the characters that have a
none, or to exclude some subset of those, such
as those with a
decomposition_type equal to
There are circumstance in which identifers are expected to more fully encompass words or phrases used in natural languages. In these cases, a profile should consider whether the following characters should be allowed in identifiers, and perhaps others, depending on the languages in question. In some environments even spaces are allowed in identifiers, such as in SQL: SELECT * FROM Employee Pension.
0027 (') APOSTROPHE
002D (-) HYPHEN-MINUS
002E (.) FULL STOP
003A (:) COLON
00B7 (·) MIDDLE DOT
058A (֊) ARMENIAN HYPHEN
05F3 (׳) HEBREW PUNCTUATION GERESH
05F4 (״) HEBREW PUNCTUATION GERSHAYIM
200C () ZERO WIDTH NON-JOINER
200D () ZERO WIDTH JOINER
2010 (‐) HYPHEN
2019 (’) RIGHT SINGLE QUOTATION MARK
2027 (‧) HYPHENATION POINT
30A0 (゠) KATAKANA-HIRAGANA DOUBLE HYPHEN
For more information on characters that may occur in words, see Section 4, Word Boundaries in [UAX29].
For programming language identifiers, normalization and case have a number of important implications. For a discussion of these issues, see Section 5, Normalization and Case.
Unicode General_Category values are kept as stable as possible, but they can change across
versions of the Unicode Standard. The bulk of the characters having a given value are determined
by other properties, and the coverage expands in the future according to the assignment of those
properties. In addition, the Other_ID_Start property adds a small list of characters that
ID_Start characters in some previous version of
Unicode solely on the basis of their General_Category properties, but that
no longer qualify in the current version. This list consists of four characters:
U+2118 Script Capital P U+212E Estimated Symbol U+309B Katakana-Hiragana Voiced Sound Mark U+309C Katakana-Hiragana Semi-Voiced Sound Mark
Similarly, the Other_ID_Continue property adds a small list of characters that qualified as
ID_Continue characters in some previous version of Unicode solely on the basis of
their General_Category properties, but that no longer qualify in the current version.
This list consists of nine characters:
U+1369 ETHIOPIC DIGIT ONE ... U+1371 ETHIOPIC DIGIT NINE
The Other_ID_Start and Other_ID_Continue properties are thus designed to ensure that the Unicode identifier specification is backward compatible: Any sequence of characters that qualified as an identifier in some version of Unicode will continue to qualify as an identifier in future versions.
|To meet this requirement, an implementation shall use the D1 and the
properties ID_Start and ID_Continue (or XID_Start and XID_Continue) to determine whether a
string is an identifier or not.
Or, it shall declare that it uses a
profile, and define that profile with a precise list
of characters that are added to or removed from the above properties, and/or provide a list of
additional constraints on identifiers.
The disadvantage of working with the lexical classes defined above is the storage space needed for the detailed definitions, plus the fact that with each new version of the Unicode Standard new characters are added, which an existing parser would not be able to recognize. In other words, the recommendations based on that table are not upwardly compatible.
This problem can be addressed by turning the question around. Instead of defining the set of code points that are allowed, define a small, fixed set of code points that are reserved for syntactic use and allow everything else (including unassigned code points) as part of an identifier. All parsers written to this specification would behave the same way for all versions of the Unicode Standard, because the classification of code points is fixed forever.
The drawback of this method is that it allows “nonsense” to be part of identifiers because the concerns of lexical classification and of human intelligibility are separated. Human intelligibility can, however, be addressed by other means, such as usage guidelines that encourage a restriction to meaningful terms for identifiers. For an example of such guidelines, see the XML 1.1 specification by the W3C [XML1.1].
By increasing the set of disallowed characters, a reasonably intuitive recommendation for identifiers can be achieved. This approach uses the full specification of identifier classes, as of a particular version of the Unicode Standard, and permanently disallows any characters not recommended in that version for inclusion in identifiers. All code points unassigned as of that version would be allowed in identifiers, so that any future additions to the standard would already be accounted for. This approach ensures both upwardly compatible identifier stability and a reasonable division of characters into those that do and do not make human sense as part of identifiers.
With or without such fine-tuning, such a compromise approach still incurs the expense of implementing large lists of code points. While they no longer change over time, it is a matter of choice whether the benefit of enforcing somewhat word-like identifiers justifies their cost.
Alternatively, one can use the properties described below, and allow all sequences of characters to be identifiers that are neither Pattern_Syntax nor Pattern_White_Space. This has the advantage of simplicity and small tables, but allows many more “unnatural” identifiers.
|To meet this requirement, an implementation shall define identifiers to
be any string of characters that contains neither Pattern_White_Space nor Pattern_Syntax
Or, it shall declare that it uses a uses a profile,
and define that profile with a precise list of characters that are added to or removed
from the sets of code points defined by these properties.
There are many circumstances where software interprets patterns that are a mixture of literal characters, whitespace, and syntax characters. Examples include regular expressions, Java collation rules, Excel or ICU number formats, and many others. In the past, regular expressions and other formal languages have been forced to use clumsy combinations of ASCII characters for their syntax. As Unicode becomes ubiquitous, some of these will start to use non-ASCII characters for their syntax: first as more readable optional alternatives, then eventually as the standard syntax.
For forward and backward compatibility, it is advantageous to have a fixed set of whitespace and syntax code points for use in patterns. This follows the recommendations that the Unicode Consortium made regarding completely stable identifiers, and the practice that is seen in XML 1.1 [XML1.1]. (In particular, the Unicode Consortium is committed to not allocating characters suitable for identifiers in the range U+2190..U+2BFF, which is being used by XML 1.1.)
With a fixed set of whitespace and syntax code points, a pattern language can then have a policy requiring all possible syntax characters (even ones currently unused) to be quoted if they are literals. Using this policy preserves the freedom to extend the syntax in the future by using those characters. Past patterns on future systems will always work; future patterns on past systems will signal an error instead of silently producing the wrong results.
In version 1.3 of program X, '≈' is a reserved syntax character: that is, it does not perform an operation, and it needs to be quoted. In this example, '\' quotes the next character; that is, causes it to be treated as a literal instead of a syntax character. In version 1.4 of program X, '≈' gets a real meaning, for example, “uppercase the subsequent characters”.
- The pattern abc...\≈...xyz works on both version 1.3 and 1.4, and refers to the literal character because it is quoted in both cases.
- The pattern abc...≈...xyz works on 1.1 and uppercases the following characters. On version 1.0, the engine (rightfully) has no idea what to do with ≈. Rather than silently fail (by ignoring ≈ or turning it into a literal), it has the opportunity signal an error.
As of Unicode 4.1.0, there are two Unicode character properties that can be used for for stable syntax: Pattern_White_Space and Pattern_Syntax. Particular pattern languages may, of course, override these recommendations (for example, adding or removing other characters for compatibility in ASCII).
For stability, the values of these properties are absolutely invariant; not changing with successive versions of Unicode. Of course, this does not limit the ability of the Unicode Standard to add more symbol or whitespace characters, but the syntax and whitespace characters recommended for use in patterns will not change.
When generating rules or patterns, all whitespace and syntax code points that are to be literals require quoting, using whatever quoting mechanism is available. For readability, it is recommended practice to quote or escape all literal whitespace and default ignorable code points as well.
Consider the following, where the items in angle brackets indicate literal characters.
a<SPACE>b => x<ZERO WIDTH SPACE>y + z;
Because <SPACE> is a Pattern_White_Space character, it requires quoting. Because <ZERO WIDTH SPACE> is a default ignorable character, it should also be quoted for readability. So if in this example \uXXXX is used for hex expression, but resolved before quoting, and single quotes are used for quoting, this might be expressed as:
'a\u0020b' => 'x\u200By' + z;
|R3||Pattern_White_Space and Pattern_Syntax Characters|
|To meet this requirement, an implementation shall use Pattern_White_Space
characters as all and only those characters interpreted as whitespace in parsing, and shall
use Pattern_Syntax characters as all and only those characters with syntactic use.
Or, it shall declare that it uses a profile, and define that profile with a precise list of characters that are added to or removed from the sets of code points defined by these properties.
|To meet this requirement, an implementation shall specify the
normalization form, and shall provide a precise list of any characters that are excluded from
normalization. If the normalization form is NFKC, the implementation shall apply the modifications in
Section 5.1, NFKC Modifications given by the properties XID_Start
and XID_Continue. Except for identifiers containing excluded characters, any two
identifiers that have the same normalization form shall be treated as equivalent by the
|To meet this requirement, an implementation shall specify either simple or full casefolding, and adhere to the Unicode specification for that folding. Any two identifiers that have the same casefolded form shall be treated as equivalent by the implementation.|
This section discusses issues that must be taken into account when considering normalization and casefolding of identifiers in programming languages or scripting languages. Using normalization avoids many problems where apparently identical identifiers are not treated equivalently. Such problems can appear both during compilation and during linking, in particular across different programming languages. To avoid such problems, programming languages can normalize identifiers before storing or comparing them. Generally if the programming language has case-sensitive identifiers then Normalization Form C is appropriate, while if the programming language has case-insensitive identifiers then Normalization Form KC is more appropriate.
Note: In mathematically-oriented programming languages which make distinctive use of the Mathematical Alphanumeric Symbols, such as U+1D400 MATHEMATICAL BOLD CAPITAL A, an application of NFKC must filter characters to exclude characters with the property value
decomposition_type=font. For related information, see Unicode Technical Report #30, “Character Foldings”.
Where programming languages are using NFKC to fold differences between characters, they need the following modifications of the identifier syntax from the Unicode Standard to deal with the idiosyncrasies of a small number of characters. These modifications are reflected in the XID_Start and XID_Continue properties.
ID_Continue. If the programming language is using a dot as an operator, then U+2219 BULLET OPERATOR or U+22C5 DOT OPERATOR should be used instead. However, care should be taken when dealing with U+00B7 MIDDLE DOT, as many processes will assume its use as punctuation, rather than as a letter extender.
XID_Continue. It is recommended that all Arabic presentation forms be excluded from identifiers in any event, although only a few of them must be excluded for normalization to guarantee identifier closure.
With these amendments to the identifier syntax, all identifiers are closed under all four Normalization forms. Identifiers are also closed under case operations (with one exception). This means that for any string S:
The one exception for casing is U+0345 COMBINING GREEK YPOGEGRAMMENI.
In the very unusual case that U+0345 is at the start of S,
U+0345 is not in
but its uppercase and casefolded version are. In practice this is not a problem, because of the
way normalization is used with identifiers.
Note: Those programming languages with case-insensitive identifiers should use the casefoldings described in Section 3.13, Default Case Algorithms of [Unicode] to produce a case-insensitive normalized form.
When source text is parsed for identifiers, the folding of distinctions (using case mapping or NFKC) must be delayed until after parsing has located the identifiers. Thus, such folding of distinctions should not be applied to string literals or to comments in program source text.
The Unicode Character Database (UCD) provides support for handling casefolding with normalization: the property FC_NFKC_Closure can be used in casefolding, so that a casefolding of an NFKC string is itself normalized. These properties, and the files containing them, are described in the UCD documentation [UCD].
Mark Davis is the author of the initial version and has added to and maintained the text of this annex.
Thanks to Eric Muller, Asmus Freytag, Julie Allen, Kenneth Whistler, and Martin Duerst for feedback on this annex.
For references for this annex, see Unicode Standard Annex #41, “Common References for Unicode Standard Annexes.”
For details of the change history, see the online copy of this annex at http://www.unicode.org/reports/tr31/.
The following summarizes modifications from previous revisions of this annex.
Unicode and the Unicode logo are trademarks of Unicode, Inc., and are registered in some jurisdictions.