W3C XML Schema supports the classical Perl character classes plus a couple of additions to match XML-specific productions. Each class is designated by a single letter; the classes designated by the upper- and lowercase versions of the same letter are complementary:

These character classes can be used with an optional quantifier like any other atom. The last pattern facet that you saw:

multipleOfTen = xsd:integer {pattern = ".*0"}

constrains the lexical space to be a string of characters ending with a zero. Knowing that the base type is an xsd:integer, is good enough for our purposes, but if the base type had been an xsd:decimal (or xsd:string), you can be more restrictive and write:

multipleOfTen = xsd:integer {pattern = "-?\d*0"}

This syntax checks that the characters before the trailing zero are digits with an optional leading - (you'll see later how to specify an optional leading - or +).

Patterns support character classes matching both Unicode categories and blocks. Categories and blocks are two complementary classification systems: categories classify the characters by their usage independently of their localization (letters, uppercase, digit, punctuation, etc.); blocks classify characters by their localization independently of their usage (Latin, Arabic, Hebrew, Tibetan, and even Gothic or musical symbols).

The syntax \p{Name} is similar for blocks and categories; the prefix Is is added to the name of categories to make the distinction. The syntax \P{Name} is also available to select the characters that don't match a block or category. A list of Unicode blocks and categories is given in the specification. Table 9-2 shows the Unicode character classes, and Table 9-3 shows the Unicode character blocks.

C

Cc

Cf

Cn

Co

L

Ll

Lm

Lo

Lt

Lu

M

Mc

Me

Mn

N

Nd

Nl

No

P

Pc

Pd

Pe

Pf

Pi

Po

Ps

S

Sc

Sk

Sm

So

Z

Zl

Zp

Zs

You'll see in the next section that W3C XML Schema has introduced an extension to regular expressions to specify intersections, This extension can define the intersection between a block and a category in a single pattern facet.

Note

Although Unicode blocks seem to be a great way to restrict text to a set of characters you can print, display, read, or store in a database, they aren't designed for this purpose, and you must be careful when using them so. John Cowan, who has taught courses on Unicode and enjoys obscure alphabets, wrote about this topic: It's important to note that Unicode blocks are a very crude mechanism for discrimination: not everything needed to write Greek is in the Greek block, and there are no less than five Latin blocks, one of which (Basic Latin; i.e., ASCII) contains many script-independent symbols. The blocks were originally created solely for internal Unicode organizational purposes, and have spread to the outside world somewhat randomly. The five Latin blocks mentioned by John are BasicLatin, Latin1Supplement, LatinExtended-A, LatinExtendedAdditional, and LatinExtended-B.

These classes are lists of characters between square brackets that accept - signs to define ranges and a leading ^ to negate the whole list: for instance, the following defines the list of letters on the first row of a French keyboard:

[azertyuiop]

This expression specifies all characters between a and z:

[a-z]

This expression specifies all characters that aren't between a and z:

[^a-z]

This expression defines characters - ^ and \:

[\-^\\]

This expression specifies a decimal sign:

[\-+]

These examples demonstrate that the contents of these square brackets follows a specific syntax and semantic. Like the regular expression's main syntax, there's a list of atoms, but instead of matching each atom against a character of the instance string, you define a logical space. Brackets operate in a space between the atoms and more formal character classes.

The caret (^) is a special character that has a different meaning depending on its location. A negator when it appears at the beginning of a class, the caret loses this special meaning and acts as a normal character when it appears later in the class definition.

Tip

The support of the escape format #xXX (such as in #x2D) is a frequent source of confusion. Because this format is used in the W3C XML Schema recommendation to describe characters by their Unicode value, some people have thought to use it in regular expressions, but it is not meant to be used that way. If you want to define characters by their Unicode values, you should use numeric entities instead (such as - if you are using the XML syntax or the syntax for escaping characters in the compact syntax \x{2D}). Note that in both cases, the reference is replaced by the corresponding character at parse time and that the regular expression engine will see the actual character instead of the escape sequence.

Also, some characters may or must be escaped: \\ matches the character \. In fact, in a class definition, all the escape sequences you saw as atoms can be used. Even though some special characters lose their special meaning inside square brackets, they can always be escaped. So, the following:

[\-^\\]

can also be written as:

[\-\^\\]

or as:

[\^\\\-]

because when they are escaped, the location of the characters doesn't matter.

Within square brackets, the character \ also keeps its meaning of a reference to a Perl or Unicode class. The following:

[\d\p{Lu}]

is a set of decimal digits (Perl class \d) and uppercase letters (Unicode category "Lu").

Mathematicians have found that three basic operations are needed to manipulate sets and that these operations can be chosen from a larger set of operations. In square brackets, you've already seen two of these operations: union (the square bracket is an implicit union of its atoms) and complement (a leading ^ realizes the complement of the set defined in the square bracket). W3C XML Schema extends the syntax of Perl regular expressions to introduce a third operation: the difference between sets. The syntax follows:

[set1-[set2]]

Its meaning is that all the characters in set1 that don't belong to set2, where set1 and set2 can use all the syntactic tricks you saw earlier.

This operator can perform intersections of character classes (the intersection between two sets A and B is the difference between A and the complement of B), and you can now define a class for the BasicLatinLetters as:

[\p{IsBasicLatin}-[^\p{L}]]

Using the \P construct, which is also a complement, you can define the class as:

[\p{IsBasicLatin}-[\P{L}]]

The corresponding definition is:

<define name="BasicLatinLetters">
  <data type="token">
    <param name="pattern">[\p{IsBasicLatin}-[\P{L}]]*</param>
  </data>
</define>

or:

BasicLatinLetters = xsd:token {pattern = "[\p{IsBasicLatin}-[\P{L}]]*"}