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.

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.

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:

[dp{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}]]*"}